home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / CodeWarrior Lite / Metrowerks C⁄C++ Lite / Headers / System Extras Headers / GX Headers / PrintingMessages.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  99.3 KB  |  2,511 lines  |  [TEXT/MMCC]
  1. /*
  2.     File:        PrintingMessages.h
  3.  
  4.     Copyright:    © 1984-1994 by Apple Computer, Inc., all rights reserved.
  5.  
  6.     WARNING
  7.     This file was auto generated by the interfacer tool. Modifications
  8.     must be made to the master file.
  9.  
  10. */
  11.  
  12. #ifndef __PRINTINGMESSAGES__
  13. #define __PRINTINGMESSAGES__
  14.  
  15. #ifndef __PRINTINGMANAGER__
  16. #include <PrintingManager.h>
  17. /*    #include <Printing.h>                                        */
  18. /*        #include <Quickdraw.h>                                    */
  19. /*            #include <Types.h>                                    */
  20. /*                #include <ConditionalMacros.h>                    */
  21. /*                #include <MixedMode.h>                            */
  22. /*                    #include <Traps.h>                            */
  23. /*            #include <QuickdrawText.h>                            */
  24. /*                #include <IntlResources.h>                        */
  25. /*        #include <Dialogs.h>                                    */
  26. /*            #include <Windows.h>                                */
  27. /*                #include <Events.h>                                */
  28. /*                    #include <OSUtils.h>                        */
  29. /*                #include <Controls.h>                            */
  30. /*                    #include <Menus.h>                            */
  31. /*            #include <TextEdit.h>                                */
  32. /*    #include <Files.h>                                            */
  33. /*        #include <SegLoad.h>                                    */
  34. /*    #include <Collections.h>                                    */
  35. /*    #include <PrintingErrors.h>                                    */
  36. /*    #include <graphics types.h>                                    */
  37. /*        #include "math types.h"                                    */
  38. /*    #include <font types.h>                                        */
  39. /*    #include <scaler types.h>                                    */
  40. /*        #include "sfnt types.h"                                    */
  41. #endif
  42.  
  43. #ifndef __PRINTINGRESTYPES__
  44. #include <PrintingResTypes.h>
  45. #endif
  46.  
  47. #ifndef __MESSAGEMANAGER__
  48. #include <Messages.h>
  49. #endif
  50.  
  51. #ifndef __MENUS__
  52. #endif
  53.  
  54. #ifndef __LISTS__
  55. #include <Lists.h>
  56. /*    #include <Memory.h>                                            */
  57. #endif
  58.  
  59. #ifndef __DIALOGS__
  60. #endif
  61.  
  62. typedef struct gxPrivateFileRecord *gxSpoolFile;
  63.  
  64. typedef long gxPanelEvent;
  65.  
  66. enum  {
  67.     gxPanelNoEvt                = (gxPanelEvent)0,
  68.     gxPanelOpenEvt                = (gxPanelEvent)1,
  69.     gxPanelCloseEvt                = (gxPanelEvent)2,
  70.     gxPanelHitEvt                = (gxPanelEvent)3,
  71.     gxPanelActivateEvt            = (gxPanelEvent)4,
  72.     gxPanelDeactivateEvt        = (gxPanelEvent)5,
  73.     gxPanelIconFocusEvt            = (gxPanelEvent)6,
  74.     gxPanelPanelFocusEvt        = (gxPanelEvent)7,
  75.     gxPanelFilterEvt            = (gxPanelEvent)8,
  76.     gxPanelCancelEvt            = (gxPanelEvent)9,
  77.     gxPanelConfirmEvt            = (gxPanelEvent)10,
  78.     gxPanelDialogEvt            = (gxPanelEvent)11,
  79.     gxPanelOtherEvt                = (gxPanelEvent)12,
  80.     gxPanelUserWillConfirmEvt    = (gxPanelEvent)13
  81. };
  82.  
  83. typedef long gxPanelResult;
  84.  
  85. enum  {
  86.     gxPanelNoResult                = 0,
  87.     gxPanelCancelConfirmation    = 1
  88. };
  89.  
  90. enum  {
  91.     gxOtherAction                = 0,
  92.     gxClosePanelAction            = 1,
  93.     gxCancelDialogAction        = 2,
  94.     gxConfirmDialogAction        = 3
  95. };
  96.  
  97. #if defined(powerc) || defined (__powerc)
  98. #pragma options align=mac68k
  99. #endif
  100. struct gxPanelInfoRecord {
  101.     gxPanelEvent                panelEvt;
  102.     short                        panelResId;
  103.     DialogPtr                    pDlg;
  104.     EventRecord                    *theEvent;
  105.     short                        itemHit;
  106.     short                        itemCount;
  107.     short                        evtAction;
  108.     short                        errorStringId;
  109.     gxFormat                    theFormat;
  110.     void                        *refCon;
  111. };
  112. #if defined(powerc) || defined(__powerc)
  113. #pragma options align=reset
  114. #endif
  115.  
  116. typedef struct gxPanelInfoRecord gxPanelInfoRecord;
  117.  
  118. typedef long gxPrintingPanelKind;
  119.  
  120. enum  {
  121.     gxApplicationPanel            = (gxPrintingPanelKind)0,
  122.     gxExtensionPanel            = (gxPrintingPanelKind)1,
  123.     gxDriverPanel                = (gxPrintingPanelKind)2
  124. };
  125.  
  126. #if defined(powerc) || defined (__powerc)
  127. #pragma options align=mac68k
  128. #endif
  129. struct gxPanelSetupRecord {
  130.     gxPrintingPanelKind            panelKind;
  131.     short                        panelResId;
  132.     short                        resourceRefNum;
  133.     void                        *refCon;
  134. };
  135. #if defined(powerc) || defined(__powerc)
  136. #pragma options align=reset
  137. #endif
  138.  
  139. typedef struct gxPanelSetupRecord gxPanelSetupRecord;
  140.  
  141. typedef long gxParsePageRangeResult;
  142.  
  143. enum  {
  144.     gxRangeNotParsed            = (gxParsePageRangeResult)0,
  145.     gxRangeParsed                = (gxParsePageRangeResult)1,
  146.     gxRangeBadFromValue            = (gxParsePageRangeResult)2,
  147.     gxRangeBadToValue            = (gxParsePageRangeResult)3
  148. };
  149.  
  150. enum  {
  151.     gxNonFatalError                = 1,
  152.     gxFatalError                = 2,
  153.     gxPrinterReady                = 3,
  154.     gxUserAttention                = 4,
  155.     gxUserAlert                    = 5,
  156.     gxPageTransmission            = 6,
  157.     gxOpenConnectionStatus        = 7,
  158.     gxInformationalStatus        = 8,
  159.     gxSpoolingPageStatus        = 9,
  160.     gxEndStatus                    = 10,
  161.     gxPercentageStatus            = 11
  162. };
  163.  
  164. #if defined(powerc) || defined (__powerc)
  165. #pragma options align=mac68k
  166. #endif
  167. struct gxStatusRecord {
  168.     unsigned short                statusType;
  169.     unsigned short                statusId;
  170.     unsigned short                statusAlertId;
  171.     Signature                    statusOwner;
  172.     short                        statResId;
  173.     short                        statResIndex;
  174.     short                        dialogResult;
  175.     unsigned short                bufferLen;
  176.     char                        statusBuffer[1];
  177. };
  178. #if defined(powerc) || defined(__powerc)
  179. #pragma options align=reset
  180. #endif
  181.  
  182. typedef struct gxStatusRecord gxStatusRecord;
  183.  
  184. #if defined(powerc) || defined (__powerc)
  185. #pragma options align=mac68k
  186. #endif
  187. struct gxDisplayRecord {
  188.     Boolean                        useText;
  189.     Handle                        hPicture;
  190.     Str255                        theText;
  191. };
  192. #if defined(powerc) || defined(__powerc)
  193. #pragma options align=reset
  194. #endif
  195.  
  196. typedef struct gxDisplayRecord gxDisplayRecord;
  197.  
  198. typedef long gxTrayMapping;
  199.  
  200. enum  {
  201.     gxDefaultTrayMapping        = (gxTrayMapping)0,
  202.     gxConfiguredTrayMapping        = (gxTrayMapping)1
  203. };
  204.  
  205. #define GXPROTECTEDAPIGLUE(selector) {0x203C, 0x0001, selector, 0xABFE}
  206.  
  207. #define GXPRINTINGDISPATCH(segID, selector) {0x203C, 0x0001, 0, 0x223C, (segID & 0x0FFF), selector << 2, 0xABFE}
  208.  
  209. #ifdef __cplusplus
  210. extern "C" {
  211. #endif
  212.  
  213. #ifndef __powerc
  214. #ifdef applec
  215. #else
  216. #endif
  217.  
  218. #endif
  219.  
  220. extern gxJob GXGetJob(void)
  221.  FOURWORDINLINE(0x203C, 0x0001, 1, 0xABFE);
  222. extern short GXGetMessageHandlerResFile(void)
  223.  FOURWORDINLINE(0x203C, 0x0001, 2, 0xABFE);
  224. extern Boolean GXSpoolingAborted(void)
  225.  FOURWORDINLINE(0x203C, 0x0001, 3, 0xABFE);
  226. extern OSErr GXJobIdle(void)
  227.  FOURWORDINLINE(0x203C, 0x0001, 4, 0xABFE);
  228. #if defined(applec) && !defined(powerc)
  229. extern OSErr GXReportStatus(short statusID, unsigned short statusIndex)
  230.  FOURWORDINLINE(0x203C, 0x0001, 5, 0xABFE);
  231. #else
  232. extern OSErr GXReportStatus(long statusID, unsigned long statusIndex)
  233.  FOURWORDINLINE(0x203C, 0x0001, 5, 0xABFE);
  234. #endif
  235.  
  236. extern OSErr GXAlertTheUser(gxStatusRecord *)
  237.  FOURWORDINLINE(0x203C, 0x0001, 6, 0xABFE);
  238. extern OSErr GXSetupDialogPanel(gxPanelSetupRecord *)
  239.  FOURWORDINLINE(0x203C, 0x0001, 7, 0xABFE);
  240. extern OSErr GXCountTrays(gxTrayIndex *numTrays)
  241.  FOURWORDINLINE(0x203C, 0x0001, 8, 0xABFE);
  242. extern OSErr GXGetTrayName(gxTrayIndex trayNumber, Str31 trayName)
  243.  FOURWORDINLINE(0x203C, 0x0001, 9, 0xABFE);
  244. extern OSErr GXSetTrayPaperType(gxTrayIndex whichTray, gxPaperType)
  245.  FOURWORDINLINE(0x203C, 0x0001, 10, 0xABFE);
  246. extern OSErr GXGetTrayPaperType(gxTrayIndex whichTray, gxPaperType)
  247.  FOURWORDINLINE(0x203C, 0x0001, 11, 0xABFE);
  248. extern OSErr GXGetTrayMapping(gxTrayMapping *trayMapping)
  249.  FOURWORDINLINE(0x203C, 0x0001, 12, 0xABFE);
  250. extern void GXCleanupStartJob(void)
  251.  FOURWORDINLINE(0x203C, 0x0001, 13, 0xABFE);
  252. extern void GXCleanupStartPage(void)
  253.  FOURWORDINLINE(0x203C, 0x0001, 14, 0xABFE);
  254. extern void GXCleanupOpenConnection(void)
  255.  FOURWORDINLINE(0x203C, 0x0001, 15, 0xABFE);
  256. extern void GXCleanupStartSendPage(void)
  257.  FOURWORDINLINE(0x203C, 0x0001, 16, 0xABFE);
  258. enum  {
  259.     gxNoCreateOptions            = 0x00000000,
  260.     gxInhibitAlias                = 0x00000001,
  261.     gxInhibitUniqueName            = 0x00000002,
  262.     gxResolveBitmapAlias        = 0x00000004
  263. };
  264.  
  265. enum  {
  266.     gxNoCloseOptions            = 0x00000000,
  267.     gxDeleteOnClose                = 0x00000001,
  268.     gxUpdateJobData                = 0x00000002,
  269.     gxMakeRemoteFile            = 0x00000004
  270. };
  271.  
  272. enum  {
  273.     gxNoImageFile                = 0x00000000,
  274.     gxMakeImageFile                = 0x00000001,
  275.     gxEachPlane                    = 0x00000002,
  276.     gxEachPage                    = 0x00000004,
  277.     gxEntireFile                = gxEachPlane + gxEachPage
  278. };
  279.  
  280. enum  {
  281.     gxNoBufferOptions            = 0x00000000,
  282.     gxMakeBufferHex                = 0x00000001,
  283.     gxDontSplitBuffer            = 0x00000002
  284. };
  285.  
  286. #if defined(powerc) || defined (__powerc)
  287. #pragma options align=mac68k
  288. #endif
  289. struct gxPrintingBuffer {
  290.     long                        size;
  291.     long                        userData;
  292.     char                        data[1];
  293. };
  294. #if defined(powerc) || defined(__powerc)
  295. #pragma options align=reset
  296. #endif
  297.  
  298. typedef struct gxPrintingBuffer gxPrintingBuffer;
  299.  
  300. #if defined(powerc) || defined (__powerc)
  301. #pragma options align=mac68k
  302. #endif
  303. struct gxPageInfoRecord {
  304.     long                        docPageNum;
  305.     long                        copyNum;
  306.     Boolean                        formatChanged;
  307.     Boolean                        pageChanged;
  308.     long                        internalUse;
  309. };
  310. #if defined(powerc) || defined(__powerc)
  311. #pragma options align=reset
  312. #endif
  313.  
  314. typedef struct gxPageInfoRecord gxPageInfoRecord;
  315.  
  316. #define GXUNIVSENDGLUE(selector) SendMessageGlue(0x0000, selector)
  317.  
  318. #define GXFORWARDGLUE ForwardThisMessageGlue
  319.  
  320. #define Send_GXFetchTaggedDriverData(tag, id, pHandle) Send_GXFetchTaggedData(tag, id, pHandle, 'drvr')
  321.  
  322. #define Forward_GXFetchTaggedDriverData(tag, id, pHandle) Forward_GXFetchTaggedData(tag, id, pHandle, 'drvr')
  323.  
  324. typedef OSErr (*GXJobIdleProcPtr)(void);
  325.  
  326. enum {
  327.     uppGXJobIdleProcInfo = kCStackBased
  328.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  329. };
  330.  
  331. #if USESROUTINEDESCRIPTORS
  332. typedef UniversalProcPtr GXJobIdleUPP;
  333.  
  334. #define CallGXJobIdleProc(userRoutine)        \
  335.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXJobIdleProcInfo)
  336. #define NewGXJobIdleProc(userRoutine)        \
  337.         (GXJobIdleUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXJobIdleProcInfo, GetCurrentISA())
  338. #else
  339. typedef GXJobIdleProcPtr GXJobIdleUPP;
  340.  
  341. #define CallGXJobIdleProc(userRoutine)        \
  342.         (*(userRoutine))()
  343. #define NewGXJobIdleProc(userRoutine)        \
  344.         (GXJobIdleUPP)(userRoutine)
  345. #endif
  346.  
  347. extern OSErr Send_GXJobIdle(void)
  348.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 2, 0xABFB);
  349. extern OSErr Forward_GXJobIdle(void)
  350.  TWOWORDINLINE(0x7036, 0xABFB);
  351. typedef OSErr (*GXJobStatusProcPtr)(gxStatusRecord *pStatus);
  352.  
  353. enum {
  354.     uppGXJobStatusProcInfo = kCStackBased
  355.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  356.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxStatusRecord*)))
  357. };
  358.  
  359. #if USESROUTINEDESCRIPTORS
  360. typedef UniversalProcPtr GXJobStatusUPP;
  361.  
  362. #define CallGXJobStatusProc(userRoutine, pStatus)        \
  363.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXJobStatusProcInfo, (pStatus))
  364. #define NewGXJobStatusProc(userRoutine)        \
  365.         (GXJobStatusUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXJobStatusProcInfo, GetCurrentISA())
  366. #else
  367. typedef GXJobStatusProcPtr GXJobStatusUPP;
  368.  
  369. #define CallGXJobStatusProc(userRoutine, pStatus)        \
  370.         (*(userRoutine))((pStatus))
  371. #define NewGXJobStatusProc(userRoutine)        \
  372.         (GXJobStatusUPP)(userRoutine)
  373. #endif
  374.  
  375. extern OSErr Send_GXJobStatus(gxStatusRecord *pStatus)
  376.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 3, 0xABFB);
  377. extern OSErr Forward_GXJobStatus(gxStatusRecord *pStatus)
  378.  TWOWORDINLINE(0x7036, 0xABFB);
  379. typedef OSErr (*GXPrintingEventProcPtr)(EventRecord *eventPtr, Boolean filterEvent);
  380.  
  381. enum {
  382.     uppGXPrintingEventProcInfo = kCStackBased
  383.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  384.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(EventRecord*)))
  385.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Boolean)))
  386. };
  387.  
  388. #if USESROUTINEDESCRIPTORS
  389. typedef UniversalProcPtr GXPrintingEventUPP;
  390.  
  391. #define CallGXPrintingEventProc(userRoutine, eventPtr, filterEvent)        \
  392.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXPrintingEventProcInfo, (eventPtr), (filterEvent))
  393. #define NewGXPrintingEventProc(userRoutine)        \
  394.         (GXPrintingEventUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXPrintingEventProcInfo, GetCurrentISA())
  395. #else
  396. typedef GXPrintingEventProcPtr GXPrintingEventUPP;
  397.  
  398. #define CallGXPrintingEventProc(userRoutine, eventPtr, filterEvent)        \
  399.         (*(userRoutine))((eventPtr), (filterEvent))
  400. #define NewGXPrintingEventProc(userRoutine)        \
  401.         (GXPrintingEventUPP)(userRoutine)
  402. #endif
  403.  
  404. extern OSErr Send_GXPrintingEvent(EventRecord *, Boolean filterEvent)
  405.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 4, 0xABFB);
  406. extern OSErr Forward_GXPrintingEvent(EventRecord *, Boolean filterEvent)
  407.  TWOWORDINLINE(0x7036, 0xABFB);
  408. typedef OSErr (*GXJobDefaultFormatDialogProcPtr)(gxDialogResult *dlgResult);
  409.  
  410. enum {
  411.     uppGXJobDefaultFormatDialogProcInfo = kCStackBased
  412.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  413.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxDialogResult*)))
  414. };
  415.  
  416. #if USESROUTINEDESCRIPTORS
  417. typedef UniversalProcPtr GXJobDefaultFormatDialogUPP;
  418.  
  419. #define CallGXJobDefaultFormatDialogProc(userRoutine, dlgResult)        \
  420.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXJobDefaultFormatDialogProcInfo, (dlgResult))
  421. #define NewGXJobDefaultFormatDialogProc(userRoutine)        \
  422.         (GXJobDefaultFormatDialogUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXJobDefaultFormatDialogProcInfo, GetCurrentISA())
  423. #else
  424. typedef GXJobDefaultFormatDialogProcPtr GXJobDefaultFormatDialogUPP;
  425.  
  426. #define CallGXJobDefaultFormatDialogProc(userRoutine, dlgResult)        \
  427.         (*(userRoutine))((dlgResult))
  428. #define NewGXJobDefaultFormatDialogProc(userRoutine)        \
  429.         (GXJobDefaultFormatDialogUPP)(userRoutine)
  430. #endif
  431.  
  432. extern OSErr Send_GXJobDefaultFormatDialog(gxDialogResult *dlgResult)
  433.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 5, 0xABFB);
  434. extern OSErr Forward_GXJobDefaultFormatDialog(gxDialogResult *dlgResult)
  435.  TWOWORDINLINE(0x7036, 0xABFB);
  436. typedef OSErr (*GXFormatDialogProcPtr)(gxFormat theFormat, StringPtr title, gxDialogResult *dlgResult);
  437.  
  438. enum {
  439.     uppGXFormatDialogProcInfo = kCStackBased
  440.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  441.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
  442.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(StringPtr)))
  443.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxDialogResult*)))
  444. };
  445.  
  446. #if USESROUTINEDESCRIPTORS
  447. typedef UniversalProcPtr GXFormatDialogUPP;
  448.  
  449. #define CallGXFormatDialogProc(userRoutine, theFormat, title, dlgResult)        \
  450.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFormatDialogProcInfo, (theFormat), (title), (dlgResult))
  451. #define NewGXFormatDialogProc(userRoutine)        \
  452.         (GXFormatDialogUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFormatDialogProcInfo, GetCurrentISA())
  453. #else
  454. typedef GXFormatDialogProcPtr GXFormatDialogUPP;
  455.  
  456. #define CallGXFormatDialogProc(userRoutine, theFormat, title, dlgResult)        \
  457.         (*(userRoutine))((theFormat), (title), (dlgResult))
  458. #define NewGXFormatDialogProc(userRoutine)        \
  459.         (GXFormatDialogUPP)(userRoutine)
  460. #endif
  461.  
  462. extern OSErr Send_GXFormatDialog(gxFormat theFormat, StringPtr title, gxDialogResult *dlgResult)
  463.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 6, 0xABFB);
  464. extern OSErr Forward_GXFormatDialog(gxFormat theFormat, StringPtr title, gxDialogResult *dlgResult)
  465.  TWOWORDINLINE(0x7036, 0xABFB);
  466. typedef OSErr (*GXJobPrintDialogProcPtr)(gxDialogResult *dlgResult);
  467.  
  468. enum {
  469.     uppGXJobPrintDialogProcInfo = kCStackBased
  470.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  471.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxDialogResult*)))
  472. };
  473.  
  474. #if USESROUTINEDESCRIPTORS
  475. typedef UniversalProcPtr GXJobPrintDialogUPP;
  476.  
  477. #define CallGXJobPrintDialogProc(userRoutine, dlgResult)        \
  478.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXJobPrintDialogProcInfo, (dlgResult))
  479. #define NewGXJobPrintDialogProc(userRoutine)        \
  480.         (GXJobPrintDialogUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXJobPrintDialogProcInfo, GetCurrentISA())
  481. #else
  482. typedef GXJobPrintDialogProcPtr GXJobPrintDialogUPP;
  483.  
  484. #define CallGXJobPrintDialogProc(userRoutine, dlgResult)        \
  485.         (*(userRoutine))((dlgResult))
  486. #define NewGXJobPrintDialogProc(userRoutine)        \
  487.         (GXJobPrintDialogUPP)(userRoutine)
  488. #endif
  489.  
  490. extern OSErr Send_GXJobPrintDialog(gxDialogResult *dlgResult)
  491.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 7, 0xABFB);
  492. extern OSErr Forward_GXJobPrintDialog(gxDialogResult *dlgResult)
  493.  TWOWORDINLINE(0x7036, 0xABFB);
  494. typedef OSErr (*GXFilterPanelEventProcPtr)(gxPanelInfoRecord *pHitInfo, Boolean *returnImmed);
  495.  
  496. enum {
  497.     uppGXFilterPanelEventProcInfo = kCStackBased
  498.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  499.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPanelInfoRecord*)))
  500.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Boolean*)))
  501. };
  502.  
  503. #if USESROUTINEDESCRIPTORS
  504. typedef UniversalProcPtr GXFilterPanelEventUPP;
  505.  
  506. #define CallGXFilterPanelEventProc(userRoutine, pHitInfo, returnImmed)        \
  507.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFilterPanelEventProcInfo, (pHitInfo), (returnImmed))
  508. #define NewGXFilterPanelEventProc(userRoutine)        \
  509.         (GXFilterPanelEventUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFilterPanelEventProcInfo, GetCurrentISA())
  510. #else
  511. typedef GXFilterPanelEventProcPtr GXFilterPanelEventUPP;
  512.  
  513. #define CallGXFilterPanelEventProc(userRoutine, pHitInfo, returnImmed)        \
  514.         (*(userRoutine))((pHitInfo), (returnImmed))
  515. #define NewGXFilterPanelEventProc(userRoutine)        \
  516.         (GXFilterPanelEventUPP)(userRoutine)
  517. #endif
  518.  
  519. extern OSErr Send_GXFilterPanelEvent(gxPanelInfoRecord *pHitInfo, Boolean *returnImmed)
  520.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 8, 0xABFB);
  521. typedef OSErr (*GXHandlePanelEventProcPtr)(gxPanelInfoRecord *pHitInfo, gxPanelResult *panelResponse);
  522.  
  523. enum {
  524.     uppGXHandlePanelEventProcInfo = kCStackBased
  525.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  526.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPanelInfoRecord*)))
  527.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxPanelResult*)))
  528. };
  529.  
  530. #if USESROUTINEDESCRIPTORS
  531. typedef UniversalProcPtr GXHandlePanelEventUPP;
  532.  
  533. #define CallGXHandlePanelEventProc(userRoutine, pHitInfo, panelResponse)        \
  534.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXHandlePanelEventProcInfo, (pHitInfo), (panelResponse))
  535. #define NewGXHandlePanelEventProc(userRoutine)        \
  536.         (GXHandlePanelEventUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXHandlePanelEventProcInfo, GetCurrentISA())
  537. #else
  538. typedef GXHandlePanelEventProcPtr GXHandlePanelEventUPP;
  539.  
  540. #define CallGXHandlePanelEventProc(userRoutine, pHitInfo, panelResponse)        \
  541.         (*(userRoutine))((pHitInfo), (panelResponse))
  542. #define NewGXHandlePanelEventProc(userRoutine)        \
  543.         (GXHandlePanelEventUPP)(userRoutine)
  544. #endif
  545.  
  546. extern OSErr Send_GXHandlePanelEvent(gxPanelInfoRecord *pHitInfo, gxPanelResult *panelResponse)
  547.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 9, 0xABFB);
  548. typedef OSErr (*GXParsePageRangeProcPtr)(StringPtr fromString, StringPtr toString, gxParsePageRangeResult *result);
  549.  
  550. enum {
  551.     uppGXParsePageRangeProcInfo = kCStackBased
  552.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  553.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(StringPtr)))
  554.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(StringPtr)))
  555.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxParsePageRangeResult*)))
  556. };
  557.  
  558. #if USESROUTINEDESCRIPTORS
  559. typedef UniversalProcPtr GXParsePageRangeUPP;
  560.  
  561. #define CallGXParsePageRangeProc(userRoutine, fromString, toString, result)        \
  562.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXParsePageRangeProcInfo, (fromString), (toString), (result))
  563. #define NewGXParsePageRangeProc(userRoutine)        \
  564.         (GXParsePageRangeUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXParsePageRangeProcInfo, GetCurrentISA())
  565. #else
  566. typedef GXParsePageRangeProcPtr GXParsePageRangeUPP;
  567.  
  568. #define CallGXParsePageRangeProc(userRoutine, fromString, toString, result)        \
  569.         (*(userRoutine))((fromString), (toString), (result))
  570. #define NewGXParsePageRangeProc(userRoutine)        \
  571.         (GXParsePageRangeUPP)(userRoutine)
  572. #endif
  573.  
  574. extern OSErr Send_GXParsePageRange(StringPtr fromString, StringPtr toString, gxParsePageRangeResult *result)
  575.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 10, 0xABFB);
  576. extern OSErr Forward_GXParsePageRange(StringPtr fromString, StringPtr toString, gxParsePageRangeResult *result)
  577.  TWOWORDINLINE(0x7036, 0xABFB);
  578. typedef OSErr (*GXDefaultJobProcPtr)(void);
  579.  
  580. enum {
  581.     uppGXDefaultJobProcInfo = kCStackBased
  582.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  583. };
  584.  
  585. #if USESROUTINEDESCRIPTORS
  586. typedef UniversalProcPtr GXDefaultJobUPP;
  587.  
  588. #define CallGXDefaultJobProc(userRoutine)        \
  589.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDefaultJobProcInfo)
  590. #define NewGXDefaultJobProc(userRoutine)        \
  591.         (GXDefaultJobUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDefaultJobProcInfo, GetCurrentISA())
  592. #else
  593. typedef GXDefaultJobProcPtr GXDefaultJobUPP;
  594.  
  595. #define CallGXDefaultJobProc(userRoutine)        \
  596.         (*(userRoutine))()
  597. #define NewGXDefaultJobProc(userRoutine)        \
  598.         (GXDefaultJobUPP)(userRoutine)
  599. #endif
  600.  
  601. extern OSErr Send_GXDefaultJob(void)
  602.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 11, 0xABFB);
  603. extern OSErr Forward_GXDefaultJob(void)
  604.  TWOWORDINLINE(0x7036, 0xABFB);
  605. typedef OSErr (*GXDefaultFormatProcPtr)(gxFormat theFormat);
  606.  
  607. enum {
  608.     uppGXDefaultFormatProcInfo = kCStackBased
  609.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  610.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
  611. };
  612.  
  613. #if USESROUTINEDESCRIPTORS
  614. typedef UniversalProcPtr GXDefaultFormatUPP;
  615.  
  616. #define CallGXDefaultFormatProc(userRoutine, theFormat)        \
  617.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDefaultFormatProcInfo, (theFormat))
  618. #define NewGXDefaultFormatProc(userRoutine)        \
  619.         (GXDefaultFormatUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDefaultFormatProcInfo, GetCurrentISA())
  620. #else
  621. typedef GXDefaultFormatProcPtr GXDefaultFormatUPP;
  622.  
  623. #define CallGXDefaultFormatProc(userRoutine, theFormat)        \
  624.         (*(userRoutine))((theFormat))
  625. #define NewGXDefaultFormatProc(userRoutine)        \
  626.         (GXDefaultFormatUPP)(userRoutine)
  627. #endif
  628.  
  629. extern OSErr Send_GXDefaultFormat(gxFormat theFormat)
  630.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 12, 0xABFB);
  631. extern OSErr Forward_GXDefaultFormat(gxFormat theFormat)
  632.  TWOWORDINLINE(0x7036, 0xABFB);
  633. typedef OSErr (*GXDefaultPaperTypeProcPtr)(gxPaperType thePaperType);
  634.  
  635. enum {
  636.     uppGXDefaultPaperTypeProcInfo = kCStackBased
  637.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  638.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPaperType)))
  639. };
  640.  
  641. #if USESROUTINEDESCRIPTORS
  642. typedef UniversalProcPtr GXDefaultPaperTypeUPP;
  643.  
  644. #define CallGXDefaultPaperTypeProc(userRoutine, thePaperType)        \
  645.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDefaultPaperTypeProcInfo, (thePaperType))
  646. #define NewGXDefaultPaperTypeProc(userRoutine)        \
  647.         (GXDefaultPaperTypeUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDefaultPaperTypeProcInfo, GetCurrentISA())
  648. #else
  649. typedef GXDefaultPaperTypeProcPtr GXDefaultPaperTypeUPP;
  650.  
  651. #define CallGXDefaultPaperTypeProc(userRoutine, thePaperType)        \
  652.         (*(userRoutine))((thePaperType))
  653. #define NewGXDefaultPaperTypeProc(userRoutine)        \
  654.         (GXDefaultPaperTypeUPP)(userRoutine)
  655. #endif
  656.  
  657. extern OSErr Send_GXDefaultPaperType(gxPaperType thePaperType)
  658.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 13, 0xABFB);
  659. extern OSErr Forward_GXDefaultPaperType(gxPaperType thePaperType)
  660.  TWOWORDINLINE(0x7036, 0xABFB);
  661. typedef OSErr (*GXDefaultPrinterProcPtr)(gxPrinter thePrinter);
  662.  
  663. enum {
  664.     uppGXDefaultPrinterProcInfo = kCStackBased
  665.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  666.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPrinter)))
  667. };
  668.  
  669. #if USESROUTINEDESCRIPTORS
  670. typedef UniversalProcPtr GXDefaultPrinterUPP;
  671.  
  672. #define CallGXDefaultPrinterProc(userRoutine, thePrinter)        \
  673.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDefaultPrinterProcInfo, (thePrinter))
  674. #define NewGXDefaultPrinterProc(userRoutine)        \
  675.         (GXDefaultPrinterUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDefaultPrinterProcInfo, GetCurrentISA())
  676. #else
  677. typedef GXDefaultPrinterProcPtr GXDefaultPrinterUPP;
  678.  
  679. #define CallGXDefaultPrinterProc(userRoutine, thePrinter)        \
  680.         (*(userRoutine))((thePrinter))
  681. #define NewGXDefaultPrinterProc(userRoutine)        \
  682.         (GXDefaultPrinterUPP)(userRoutine)
  683. #endif
  684.  
  685. extern OSErr Send_GXDefaultPrinter(gxPrinter thePrinter)
  686.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 14, 0xABFB);
  687. extern OSErr Forward_GXDefaultPrinter(gxPrinter thePrinter)
  688.  TWOWORDINLINE(0x7036, 0xABFB);
  689. typedef OSErr (*GXCreateSpoolFileProcPtr)(FSSpecPtr pFileSpec, long createOptions, gxSpoolFile *theSpoolFile);
  690.  
  691. enum {
  692.     uppGXCreateSpoolFileProcInfo = kCStackBased
  693.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  694.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(FSSpecPtr)))
  695.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  696.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxSpoolFile*)))
  697. };
  698.  
  699. #if USESROUTINEDESCRIPTORS
  700. typedef UniversalProcPtr GXCreateSpoolFileUPP;
  701.  
  702. #define CallGXCreateSpoolFileProc(userRoutine, pFileSpec, createOptions, theSpoolFile)        \
  703.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCreateSpoolFileProcInfo, (pFileSpec), (createOptions), (theSpoolFile))
  704. #define NewGXCreateSpoolFileProc(userRoutine)        \
  705.         (GXCreateSpoolFileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCreateSpoolFileProcInfo, GetCurrentISA())
  706. #else
  707. typedef GXCreateSpoolFileProcPtr GXCreateSpoolFileUPP;
  708.  
  709. #define CallGXCreateSpoolFileProc(userRoutine, pFileSpec, createOptions, theSpoolFile)        \
  710.         (*(userRoutine))((pFileSpec), (createOptions), (theSpoolFile))
  711. #define NewGXCreateSpoolFileProc(userRoutine)        \
  712.         (GXCreateSpoolFileUPP)(userRoutine)
  713. #endif
  714.  
  715. extern OSErr Send_GXCreateSpoolFile(FSSpecPtr pFileSpec, long createOptions, gxSpoolFile *theSpoolFile)
  716.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 15, 0xABFB);
  717. extern OSErr Forward_GXCreateSpoolFile(FSSpecPtr pFileSpec, long createOptions, gxSpoolFile *theSpoolFile)
  718.  TWOWORDINLINE(0x7036, 0xABFB);
  719. typedef OSErr (*GXSpoolPageProcPtr)(gxSpoolFile theSpoolFile, gxFormat theFormat, gxShape thePage);
  720.  
  721. enum {
  722.     uppGXSpoolPageProcInfo = kCStackBased
  723.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  724.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  725.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxFormat)))
  726.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxShape)))
  727. };
  728.  
  729. #if USESROUTINEDESCRIPTORS
  730. typedef UniversalProcPtr GXSpoolPageUPP;
  731.  
  732. #define CallGXSpoolPageProc(userRoutine, theSpoolFile, theFormat, thePage)        \
  733.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSpoolPageProcInfo, (theSpoolFile), (theFormat), (thePage))
  734. #define NewGXSpoolPageProc(userRoutine)        \
  735.         (GXSpoolPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSpoolPageProcInfo, GetCurrentISA())
  736. #else
  737. typedef GXSpoolPageProcPtr GXSpoolPageUPP;
  738.  
  739. #define CallGXSpoolPageProc(userRoutine, theSpoolFile, theFormat, thePage)        \
  740.         (*(userRoutine))((theSpoolFile), (theFormat), (thePage))
  741. #define NewGXSpoolPageProc(userRoutine)        \
  742.         (GXSpoolPageUPP)(userRoutine)
  743. #endif
  744.  
  745. extern OSErr Send_GXSpoolPage(gxSpoolFile theSpoolFile, gxFormat theFormat, gxShape thePage)
  746.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 16, 0xABFB);
  747. extern OSErr Forward_GXSpoolPage(gxSpoolFile theSpoolFile, gxFormat theFormat, gxShape thePage)
  748.  TWOWORDINLINE(0x7036, 0xABFB);
  749. typedef OSErr (*GXSpoolDataProcPtr)(gxSpoolFile theSpoolFile, Ptr data, long *length);
  750.  
  751. enum {
  752.     uppGXSpoolDataProcInfo = kCStackBased
  753.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  754.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  755.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr)))
  756.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long*)))
  757. };
  758.  
  759. #if USESROUTINEDESCRIPTORS
  760. typedef UniversalProcPtr GXSpoolDataUPP;
  761.  
  762. #define CallGXSpoolDataProc(userRoutine, theSpoolFile, data, length)        \
  763.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSpoolDataProcInfo, (theSpoolFile), (data), (length))
  764. #define NewGXSpoolDataProc(userRoutine)        \
  765.         (GXSpoolDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSpoolDataProcInfo, GetCurrentISA())
  766. #else
  767. typedef GXSpoolDataProcPtr GXSpoolDataUPP;
  768.  
  769. #define CallGXSpoolDataProc(userRoutine, theSpoolFile, data, length)        \
  770.         (*(userRoutine))((theSpoolFile), (data), (length))
  771. #define NewGXSpoolDataProc(userRoutine)        \
  772.         (GXSpoolDataUPP)(userRoutine)
  773. #endif
  774.  
  775. extern OSErr Send_GXSpoolData(gxSpoolFile theSpoolFile, Ptr data, long *length)
  776.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 17, 0xABFB);
  777. extern OSErr Forward_GXSpoolData(gxSpoolFile theSpoolFile, Ptr data, long *length)
  778.  TWOWORDINLINE(0x7036, 0xABFB);
  779. #if defined(applec) && !defined(powerc)
  780. typedef OSErr (*GXSpoolResourceProcPtr)(gxSpoolFile theSpoolFile, Handle theResource, ResType theType, short id);
  781.  
  782. enum {
  783.     uppGXSpoolResourceProcInfo = kCStackBased
  784.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  785.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  786.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Handle)))
  787.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(ResType)))
  788.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(short)))
  789. };
  790.  
  791. #if USESROUTINEDESCRIPTORS
  792. typedef UniversalProcPtr GXSpoolResourceUPP;
  793.  
  794. #define CallGXSpoolResourceProc(userRoutine, theSpoolFile, theResource, theType, id)        \
  795.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSpoolResourceProcInfo, (theSpoolFile), (theResource), (theType), (id))
  796. #define NewGXSpoolResourceProc(userRoutine)        \
  797.         (GXSpoolResourceUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSpoolResourceProcInfo, GetCurrentISA())
  798. #else
  799. typedef GXSpoolResourceProcPtr GXSpoolResourceUPP;
  800.  
  801. #define CallGXSpoolResourceProc(userRoutine, theSpoolFile, theResource, theType, id)        \
  802.         (*(userRoutine))((theSpoolFile), (theResource), (theType), (id))
  803. #define NewGXSpoolResourceProc(userRoutine)        \
  804.         (GXSpoolResourceUPP)(userRoutine)
  805. #endif
  806.  
  807. extern OSErr Send_GXSpoolResource(gxSpoolFile theSpoolFile, Handle theResource, ResType theType, short id)
  808.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 18, 0xABFB);
  809. extern OSErr Forward_GXSpoolResource(gxSpoolFile theSpoolFile, Handle theResource, ResType theType, short id)
  810.  TWOWORDINLINE(0x7036, 0xABFB);
  811. #else
  812. typedef OSErr (*GXSpoolResourceProcPtr)(gxSpoolFile theSpoolFile, Handle theResource, ResType theType, long id);
  813.  
  814. enum {
  815.     uppGXSpoolResourceProcInfo = kCStackBased
  816.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  817.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  818.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Handle)))
  819.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(ResType)))
  820.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long)))
  821. };
  822.  
  823. #if USESROUTINEDESCRIPTORS
  824. typedef UniversalProcPtr GXSpoolResourceUPP;
  825.  
  826. #define CallGXSpoolResourceProc(userRoutine, theSpoolFile, theResource, theType, id)        \
  827.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSpoolResourceProcInfo, (theSpoolFile), (theResource), (theType), (id))
  828. #define NewGXSpoolResourceProc(userRoutine)        \
  829.         (GXSpoolResourceUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSpoolResourceProcInfo, GetCurrentISA())
  830. #else
  831. typedef GXSpoolResourceProcPtr GXSpoolResourceUPP;
  832.  
  833. #define CallGXSpoolResourceProc(userRoutine, theSpoolFile, theResource, theType, id)        \
  834.         (*(userRoutine))((theSpoolFile), (theResource), (theType), (id))
  835. #define NewGXSpoolResourceProc(userRoutine)        \
  836.         (GXSpoolResourceUPP)(userRoutine)
  837. #endif
  838.  
  839. extern OSErr Send_GXSpoolResource(gxSpoolFile theSpoolFile, Handle theResource, ResType theType, long id)
  840.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 18, 0xABFB);
  841. extern OSErr Forward_GXSpoolResource(gxSpoolFile theSpoolFile, Handle theResource, ResType theType, long id)
  842.  TWOWORDINLINE(0x7036, 0xABFB);
  843. #endif
  844.  
  845. typedef OSErr (*GXCompleteSpoolFileProcPtr)(gxSpoolFile theSpoolFile);
  846.  
  847. enum {
  848.     uppGXCompleteSpoolFileProcInfo = kCStackBased
  849.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  850.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  851. };
  852.  
  853. #if USESROUTINEDESCRIPTORS
  854. typedef UniversalProcPtr GXCompleteSpoolFileUPP;
  855.  
  856. #define CallGXCompleteSpoolFileProc(userRoutine, theSpoolFile)        \
  857.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCompleteSpoolFileProcInfo, (theSpoolFile))
  858. #define NewGXCompleteSpoolFileProc(userRoutine)        \
  859.         (GXCompleteSpoolFileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCompleteSpoolFileProcInfo, GetCurrentISA())
  860. #else
  861. typedef GXCompleteSpoolFileProcPtr GXCompleteSpoolFileUPP;
  862.  
  863. #define CallGXCompleteSpoolFileProc(userRoutine, theSpoolFile)        \
  864.         (*(userRoutine))((theSpoolFile))
  865. #define NewGXCompleteSpoolFileProc(userRoutine)        \
  866.         (GXCompleteSpoolFileUPP)(userRoutine)
  867. #endif
  868.  
  869. extern OSErr Send_GXCompleteSpoolFile(gxSpoolFile theSpoolFile)
  870.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 19, 0xABFB);
  871. extern OSErr Forward_GXCompleteSpoolFile(gxSpoolFile theSpoolFile)
  872.  TWOWORDINLINE(0x7036, 0xABFB);
  873. typedef OSErr (*GXCountPagesProcPtr)(gxSpoolFile theSpoolFile, long *numPages);
  874.  
  875. enum {
  876.     uppGXCountPagesProcInfo = kCStackBased
  877.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  878.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  879.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long*)))
  880. };
  881.  
  882. #if USESROUTINEDESCRIPTORS
  883. typedef UniversalProcPtr GXCountPagesUPP;
  884.  
  885. #define CallGXCountPagesProc(userRoutine, theSpoolFile, numPages)        \
  886.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCountPagesProcInfo, (theSpoolFile), (numPages))
  887. #define NewGXCountPagesProc(userRoutine)        \
  888.         (GXCountPagesUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCountPagesProcInfo, GetCurrentISA())
  889. #else
  890. typedef GXCountPagesProcPtr GXCountPagesUPP;
  891.  
  892. #define CallGXCountPagesProc(userRoutine, theSpoolFile, numPages)        \
  893.         (*(userRoutine))((theSpoolFile), (numPages))
  894. #define NewGXCountPagesProc(userRoutine)        \
  895.         (GXCountPagesUPP)(userRoutine)
  896. #endif
  897.  
  898. extern OSErr Send_GXCountPages(gxSpoolFile theSpoolFile, long *numPages)
  899.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 20, 0xABFB);
  900. extern OSErr Forward_GXCountPages(gxSpoolFile theSpoolFile, long *numPages)
  901.  TWOWORDINLINE(0x7036, 0xABFB);
  902. typedef OSErr (*GXDespoolPageProcPtr)(gxSpoolFile theSpoolFile, long numPages, gxFormat theFormat, gxShape *thePage, Boolean *formatChanged);
  903.  
  904. enum {
  905.     uppGXDespoolPageProcInfo = kCStackBased
  906.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  907.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  908.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  909.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxFormat)))
  910.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(gxShape*)))
  911.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Boolean*)))
  912. };
  913.  
  914. #if USESROUTINEDESCRIPTORS
  915. typedef UniversalProcPtr GXDespoolPageUPP;
  916.  
  917. #define CallGXDespoolPageProc(userRoutine, theSpoolFile, numPages, theFormat, thePage, formatChanged)        \
  918.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDespoolPageProcInfo, (theSpoolFile), (numPages), (theFormat), (thePage), (formatChanged))
  919. #define NewGXDespoolPageProc(userRoutine)        \
  920.         (GXDespoolPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDespoolPageProcInfo, GetCurrentISA())
  921. #else
  922. typedef GXDespoolPageProcPtr GXDespoolPageUPP;
  923.  
  924. #define CallGXDespoolPageProc(userRoutine, theSpoolFile, numPages, theFormat, thePage, formatChanged)        \
  925.         (*(userRoutine))((theSpoolFile), (numPages), (theFormat), (thePage), (formatChanged))
  926. #define NewGXDespoolPageProc(userRoutine)        \
  927.         (GXDespoolPageUPP)(userRoutine)
  928. #endif
  929.  
  930. extern OSErr Send_GXDespoolPage(gxSpoolFile theSpoolFile, long numPages, gxFormat theFormat, gxShape *thePage, Boolean *formatChanged)
  931.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 21, 0xABFB);
  932. extern OSErr Forward_GXDespoolPage(gxSpoolFile theSpoolFile, long numPages, gxFormat theFormat, gxShape *thePage, Boolean *formatChanged)
  933.  TWOWORDINLINE(0x7036, 0xABFB);
  934. typedef OSErr (*GXDespoolDataProcPtr)(gxSpoolFile theSpoolFile, Ptr data, long *length);
  935.  
  936. enum {
  937.     uppGXDespoolDataProcInfo = kCStackBased
  938.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  939.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  940.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Ptr)))
  941.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long*)))
  942. };
  943.  
  944. #if USESROUTINEDESCRIPTORS
  945. typedef UniversalProcPtr GXDespoolDataUPP;
  946.  
  947. #define CallGXDespoolDataProc(userRoutine, theSpoolFile, data, length)        \
  948.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDespoolDataProcInfo, (theSpoolFile), (data), (length))
  949. #define NewGXDespoolDataProc(userRoutine)        \
  950.         (GXDespoolDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDespoolDataProcInfo, GetCurrentISA())
  951. #else
  952. typedef GXDespoolDataProcPtr GXDespoolDataUPP;
  953.  
  954. #define CallGXDespoolDataProc(userRoutine, theSpoolFile, data, length)        \
  955.         (*(userRoutine))((theSpoolFile), (data), (length))
  956. #define NewGXDespoolDataProc(userRoutine)        \
  957.         (GXDespoolDataUPP)(userRoutine)
  958. #endif
  959.  
  960. extern OSErr Send_GXDespoolData(gxSpoolFile theSpoolFile, Ptr data, long *length)
  961.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 22, 0xABFB);
  962. extern OSErr Forward_GXDespoolData(gxSpoolFile theSpoolFile, Ptr data, long *length)
  963.  TWOWORDINLINE(0x7036, 0xABFB);
  964. #if defined(applec) && !defined(powerc)
  965. typedef OSErr (*GXDespoolResourceProcPtr)(gxSpoolFile theSpoolFile, ResType theType, short id, Handle *theResource);
  966.  
  967. enum {
  968.     uppGXDespoolResourceProcInfo = kCStackBased
  969.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  970.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  971.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(ResType)))
  972.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(short)))
  973.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(Handle*)))
  974. };
  975.  
  976. #if USESROUTINEDESCRIPTORS
  977. typedef UniversalProcPtr GXDespoolResourceUPP;
  978.  
  979. #define CallGXDespoolResourceProc(userRoutine, theSpoolFile, theType, id, theResource)        \
  980.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDespoolResourceProcInfo, (theSpoolFile), (theType), (id), (theResource))
  981. #define NewGXDespoolResourceProc(userRoutine)        \
  982.         (GXDespoolResourceUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDespoolResourceProcInfo, GetCurrentISA())
  983. #else
  984. typedef GXDespoolResourceProcPtr GXDespoolResourceUPP;
  985.  
  986. #define CallGXDespoolResourceProc(userRoutine, theSpoolFile, theType, id, theResource)        \
  987.         (*(userRoutine))((theSpoolFile), (theType), (id), (theResource))
  988. #define NewGXDespoolResourceProc(userRoutine)        \
  989.         (GXDespoolResourceUPP)(userRoutine)
  990. #endif
  991.  
  992. extern OSErr Send_GXDespoolResource(gxSpoolFile theSpoolFile, ResType theType, short id, Handle *theResource)
  993.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 23, 0xABFB);
  994. extern OSErr Forward_GXDespoolResource(gxSpoolFile theSpoolFile, ResType theType, short id, Handle *theResource)
  995.  TWOWORDINLINE(0x7036, 0xABFB);
  996. #else
  997. typedef OSErr (*GXDespoolResourceProcPtr)(gxSpoolFile theSpoolFile, ResType theType, long id, Handle *theResource);
  998.  
  999. enum {
  1000.     uppGXDespoolResourceProcInfo = kCStackBased
  1001.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1002.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  1003.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(ResType)))
  1004.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
  1005.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(Handle*)))
  1006. };
  1007.  
  1008. #if USESROUTINEDESCRIPTORS
  1009. typedef UniversalProcPtr GXDespoolResourceUPP;
  1010.  
  1011. #define CallGXDespoolResourceProc(userRoutine, theSpoolFile, theType, id, theResource)        \
  1012.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDespoolResourceProcInfo, (theSpoolFile), (theType), (id), (theResource))
  1013. #define NewGXDespoolResourceProc(userRoutine)        \
  1014.         (GXDespoolResourceUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDespoolResourceProcInfo, GetCurrentISA())
  1015. #else
  1016. typedef GXDespoolResourceProcPtr GXDespoolResourceUPP;
  1017.  
  1018. #define CallGXDespoolResourceProc(userRoutine, theSpoolFile, theType, id, theResource)        \
  1019.         (*(userRoutine))((theSpoolFile), (theType), (id), (theResource))
  1020. #define NewGXDespoolResourceProc(userRoutine)        \
  1021.         (GXDespoolResourceUPP)(userRoutine)
  1022. #endif
  1023.  
  1024. extern OSErr Send_GXDespoolResource(gxSpoolFile theSpoolFile, ResType theType, long id, Handle *theResource)
  1025.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 23, 0xABFB);
  1026. extern OSErr Forward_GXDespoolResource(gxSpoolFile theSpoolFile, ResType theType, long id, Handle *theResource)
  1027.  TWOWORDINLINE(0x7036, 0xABFB);
  1028. #endif
  1029.  
  1030. typedef OSErr (*GXCloseSpoolFileProcPtr)(gxSpoolFile theSpoolFile, long closeOptions);
  1031.  
  1032. enum {
  1033.     uppGXCloseSpoolFileProcInfo = kCStackBased
  1034.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1035.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  1036.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  1037. };
  1038.  
  1039. #if USESROUTINEDESCRIPTORS
  1040. typedef UniversalProcPtr GXCloseSpoolFileUPP;
  1041.  
  1042. #define CallGXCloseSpoolFileProc(userRoutine, theSpoolFile, closeOptions)        \
  1043.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCloseSpoolFileProcInfo, (theSpoolFile), (closeOptions))
  1044. #define NewGXCloseSpoolFileProc(userRoutine)        \
  1045.         (GXCloseSpoolFileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCloseSpoolFileProcInfo, GetCurrentISA())
  1046. #else
  1047. typedef GXCloseSpoolFileProcPtr GXCloseSpoolFileUPP;
  1048.  
  1049. #define CallGXCloseSpoolFileProc(userRoutine, theSpoolFile, closeOptions)        \
  1050.         (*(userRoutine))((theSpoolFile), (closeOptions))
  1051. #define NewGXCloseSpoolFileProc(userRoutine)        \
  1052.         (GXCloseSpoolFileUPP)(userRoutine)
  1053. #endif
  1054.  
  1055. extern OSErr Send_GXCloseSpoolFile(gxSpoolFile theSpoolFile, long closeOptions)
  1056.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 24, 0xABFB);
  1057. extern OSErr Forward_GXCloseSpoolFile(gxSpoolFile theSpoolFile, long closeOptions)
  1058.  TWOWORDINLINE(0x7036, 0xABFB);
  1059. typedef OSErr (*GXStartJobProcPtr)(StringPtr docName, long pageCount);
  1060.  
  1061. enum {
  1062.     uppGXStartJobProcInfo = kCStackBased
  1063.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1064.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(StringPtr)))
  1065.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  1066. };
  1067.  
  1068. #if USESROUTINEDESCRIPTORS
  1069. typedef UniversalProcPtr GXStartJobUPP;
  1070.  
  1071. #define CallGXStartJobProc(userRoutine, docName, pageCount)        \
  1072.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXStartJobProcInfo, (docName), (pageCount))
  1073. #define NewGXStartJobProc(userRoutine)        \
  1074.         (GXStartJobUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXStartJobProcInfo, GetCurrentISA())
  1075. #else
  1076. typedef GXStartJobProcPtr GXStartJobUPP;
  1077.  
  1078. #define CallGXStartJobProc(userRoutine, docName, pageCount)        \
  1079.         (*(userRoutine))((docName), (pageCount))
  1080. #define NewGXStartJobProc(userRoutine)        \
  1081.         (GXStartJobUPP)(userRoutine)
  1082. #endif
  1083.  
  1084. extern OSErr Send_GXStartJob(StringPtr docName, long pageCount)
  1085.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 25, 0xABFB);
  1086. extern OSErr Forward_GXStartJob(StringPtr docName, long pageCount)
  1087.  TWOWORDINLINE(0x7036, 0xABFB);
  1088. typedef OSErr (*GXFinishJobProcPtr)(void);
  1089.  
  1090. enum {
  1091.     uppGXFinishJobProcInfo = kCStackBased
  1092.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1093. };
  1094.  
  1095. #if USESROUTINEDESCRIPTORS
  1096. typedef UniversalProcPtr GXFinishJobUPP;
  1097.  
  1098. #define CallGXFinishJobProc(userRoutine)        \
  1099.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFinishJobProcInfo)
  1100. #define NewGXFinishJobProc(userRoutine)        \
  1101.         (GXFinishJobUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFinishJobProcInfo, GetCurrentISA())
  1102. #else
  1103. typedef GXFinishJobProcPtr GXFinishJobUPP;
  1104.  
  1105. #define CallGXFinishJobProc(userRoutine)        \
  1106.         (*(userRoutine))()
  1107. #define NewGXFinishJobProc(userRoutine)        \
  1108.         (GXFinishJobUPP)(userRoutine)
  1109. #endif
  1110.  
  1111. extern OSErr Send_GXFinishJob(void)
  1112.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 26, 0xABFB);
  1113. extern OSErr Forward_GXFinishJob(void)
  1114.  TWOWORDINLINE(0x7036, 0xABFB);
  1115. typedef OSErr (*GXStartPageProcPtr)(gxFormat theFormat, long numViewPorts, gxViewPort *viewPortList);
  1116.  
  1117. enum {
  1118.     uppGXStartPageProcInfo = kCStackBased
  1119.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1120.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
  1121.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  1122.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxViewPort*)))
  1123. };
  1124.  
  1125. #if USESROUTINEDESCRIPTORS
  1126. typedef UniversalProcPtr GXStartPageUPP;
  1127.  
  1128. #define CallGXStartPageProc(userRoutine, theFormat, numViewPorts, viewPortList)        \
  1129.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXStartPageProcInfo, (theFormat), (numViewPorts), (viewPortList))
  1130. #define NewGXStartPageProc(userRoutine)        \
  1131.         (GXStartPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXStartPageProcInfo, GetCurrentISA())
  1132. #else
  1133. typedef GXStartPageProcPtr GXStartPageUPP;
  1134.  
  1135. #define CallGXStartPageProc(userRoutine, theFormat, numViewPorts, viewPortList)        \
  1136.         (*(userRoutine))((theFormat), (numViewPorts), (viewPortList))
  1137. #define NewGXStartPageProc(userRoutine)        \
  1138.         (GXStartPageUPP)(userRoutine)
  1139. #endif
  1140.  
  1141. extern OSErr Send_GXStartPage(gxFormat theFormat, long numViewPorts, gxViewPort *viewPortList)
  1142.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 27, 0xABFB);
  1143. extern OSErr Forward_GXStartPage(gxFormat theFormat, long numViewPorts, gxViewPort *viewPortList)
  1144.  TWOWORDINLINE(0x7036, 0xABFB);
  1145. typedef OSErr (*GXFinishPageProcPtr)(void);
  1146.  
  1147. enum {
  1148.     uppGXFinishPageProcInfo = kCStackBased
  1149.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1150. };
  1151.  
  1152. #if USESROUTINEDESCRIPTORS
  1153. typedef UniversalProcPtr GXFinishPageUPP;
  1154.  
  1155. #define CallGXFinishPageProc(userRoutine)        \
  1156.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFinishPageProcInfo)
  1157. #define NewGXFinishPageProc(userRoutine)        \
  1158.         (GXFinishPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFinishPageProcInfo, GetCurrentISA())
  1159. #else
  1160. typedef GXFinishPageProcPtr GXFinishPageUPP;
  1161.  
  1162. #define CallGXFinishPageProc(userRoutine)        \
  1163.         (*(userRoutine))()
  1164. #define NewGXFinishPageProc(userRoutine)        \
  1165.         (GXFinishPageUPP)(userRoutine)
  1166. #endif
  1167.  
  1168. extern OSErr Send_GXFinishPage(void)
  1169.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 28, 0xABFB);
  1170. extern OSErr Forward_GXFinishPage(void)
  1171.  TWOWORDINLINE(0x7036, 0xABFB);
  1172. typedef OSErr (*GXPrintPageProcPtr)(gxFormat theFormat, gxShape thePage);
  1173.  
  1174. enum {
  1175.     uppGXPrintPageProcInfo = kCStackBased
  1176.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1177.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
  1178.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxShape)))
  1179. };
  1180.  
  1181. #if USESROUTINEDESCRIPTORS
  1182. typedef UniversalProcPtr GXPrintPageUPP;
  1183.  
  1184. #define CallGXPrintPageProc(userRoutine, theFormat, thePage)        \
  1185.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXPrintPageProcInfo, (theFormat), (thePage))
  1186. #define NewGXPrintPageProc(userRoutine)        \
  1187.         (GXPrintPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXPrintPageProcInfo, GetCurrentISA())
  1188. #else
  1189. typedef GXPrintPageProcPtr GXPrintPageUPP;
  1190.  
  1191. #define CallGXPrintPageProc(userRoutine, theFormat, thePage)        \
  1192.         (*(userRoutine))((theFormat), (thePage))
  1193. #define NewGXPrintPageProc(userRoutine)        \
  1194.         (GXPrintPageUPP)(userRoutine)
  1195. #endif
  1196.  
  1197. extern OSErr Send_GXPrintPage(gxFormat theFormat, gxShape thePage)
  1198.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 29, 0xABFB);
  1199. extern OSErr Forward_GXPrintPage(gxFormat theFormat, gxShape thePage)
  1200.  TWOWORDINLINE(0x7036, 0xABFB);
  1201. typedef OSErr (*GXSetupImageDataProcPtr)(void *imageData);
  1202.  
  1203. enum {
  1204.     uppGXSetupImageDataProcInfo = kCStackBased
  1205.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1206.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(void*)))
  1207. };
  1208.  
  1209. #if USESROUTINEDESCRIPTORS
  1210. typedef UniversalProcPtr GXSetupImageDataUPP;
  1211.  
  1212. #define CallGXSetupImageDataProc(userRoutine, imageData)        \
  1213.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSetupImageDataProcInfo, (imageData))
  1214. #define NewGXSetupImageDataProc(userRoutine)        \
  1215.         (GXSetupImageDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSetupImageDataProcInfo, GetCurrentISA())
  1216. #else
  1217. typedef GXSetupImageDataProcPtr GXSetupImageDataUPP;
  1218.  
  1219. #define CallGXSetupImageDataProc(userRoutine, imageData)        \
  1220.         (*(userRoutine))((imageData))
  1221. #define NewGXSetupImageDataProc(userRoutine)        \
  1222.         (GXSetupImageDataUPP)(userRoutine)
  1223. #endif
  1224.  
  1225. extern OSErr Send_GXSetupImageData(void *imageData)
  1226.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 30, 0xABFB);
  1227. extern OSErr Forward_GXSetupImageData(void *imageData)
  1228.  TWOWORDINLINE(0x7036, 0xABFB);
  1229. typedef OSErr (*GXImageJobProcPtr)(gxSpoolFile, long *closeOptions);
  1230.  
  1231. enum {
  1232.     uppGXImageJobProcInfo = kCStackBased
  1233.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1234.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  1235.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long*)))
  1236. };
  1237.  
  1238. #if USESROUTINEDESCRIPTORS
  1239. typedef UniversalProcPtr GXImageJobUPP;
  1240.  
  1241. #define CallGXImageJobProc(userRoutine, parameter0, closeOptions)        \
  1242.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXImageJobProcInfo, (parameter0), (closeOptions))
  1243. #define NewGXImageJobProc(userRoutine)        \
  1244.         (GXImageJobUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXImageJobProcInfo, GetCurrentISA())
  1245. #else
  1246. typedef GXImageJobProcPtr GXImageJobUPP;
  1247.  
  1248. #define CallGXImageJobProc(userRoutine, parameter0, closeOptions)        \
  1249.         (*(userRoutine))((parameter0), (closeOptions))
  1250. #define NewGXImageJobProc(userRoutine)        \
  1251.         (GXImageJobUPP)(userRoutine)
  1252. #endif
  1253.  
  1254. extern OSErr Send_GXImageJob(gxSpoolFile, long *closeOptions)
  1255.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 31, 0xABFB);
  1256. extern OSErr Forward_GXImageJob(gxSpoolFile, long *closeOptions)
  1257.  TWOWORDINLINE(0x7036, 0xABFB);
  1258. typedef OSErr (*GXImageDocumentProcPtr)(gxSpoolFile theSpoolFile, void *imageData);
  1259.  
  1260. enum {
  1261.     uppGXImageDocumentProcInfo = kCStackBased
  1262.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1263.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  1264.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  1265. };
  1266.  
  1267. #if USESROUTINEDESCRIPTORS
  1268. typedef UniversalProcPtr GXImageDocumentUPP;
  1269.  
  1270. #define CallGXImageDocumentProc(userRoutine, theSpoolFile, imageData)        \
  1271.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXImageDocumentProcInfo, (theSpoolFile), (imageData))
  1272. #define NewGXImageDocumentProc(userRoutine)        \
  1273.         (GXImageDocumentUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXImageDocumentProcInfo, GetCurrentISA())
  1274. #else
  1275. typedef GXImageDocumentProcPtr GXImageDocumentUPP;
  1276.  
  1277. #define CallGXImageDocumentProc(userRoutine, theSpoolFile, imageData)        \
  1278.         (*(userRoutine))((theSpoolFile), (imageData))
  1279. #define NewGXImageDocumentProc(userRoutine)        \
  1280.         (GXImageDocumentUPP)(userRoutine)
  1281. #endif
  1282.  
  1283. extern OSErr Send_GXImageDocument(gxSpoolFile theSpoolFile, void *imageData)
  1284.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 32, 0xABFB);
  1285. extern OSErr Forward_GXImageDocument(gxSpoolFile theSpoolFile, void *imageData)
  1286.  TWOWORDINLINE(0x7036, 0xABFB);
  1287. typedef OSErr (*GXImagePageProcPtr)(gxSpoolFile theSpoolFile, long pageNumber, gxFormat theFormat, void *imageData);
  1288.  
  1289. enum {
  1290.     uppGXImagePageProcInfo = kCStackBased
  1291.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1292.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  1293.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  1294.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxFormat)))
  1295.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
  1296. };
  1297.  
  1298. #if USESROUTINEDESCRIPTORS
  1299. typedef UniversalProcPtr GXImagePageUPP;
  1300.  
  1301. #define CallGXImagePageProc(userRoutine, theSpoolFile, pageNumber, theFormat, imageData)        \
  1302.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXImagePageProcInfo, (theSpoolFile), (pageNumber), (theFormat), (imageData))
  1303. #define NewGXImagePageProc(userRoutine)        \
  1304.         (GXImagePageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXImagePageProcInfo, GetCurrentISA())
  1305. #else
  1306. typedef GXImagePageProcPtr GXImagePageUPP;
  1307.  
  1308. #define CallGXImagePageProc(userRoutine, theSpoolFile, pageNumber, theFormat, imageData)        \
  1309.         (*(userRoutine))((theSpoolFile), (pageNumber), (theFormat), (imageData))
  1310. #define NewGXImagePageProc(userRoutine)        \
  1311.         (GXImagePageUPP)(userRoutine)
  1312. #endif
  1313.  
  1314. extern OSErr Send_GXImagePage(gxSpoolFile theSpoolFile, long pageNumber, gxFormat theFormat, void *imageData)
  1315.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 33, 0xABFB);
  1316. extern OSErr Forward_GXImagePage(gxSpoolFile theSpoolFile, long pageNumber, gxFormat theFormat, void *imageData)
  1317.  TWOWORDINLINE(0x7036, 0xABFB);
  1318. typedef OSErr (*GXRenderPageProcPtr)(gxFormat theFormat, gxShape thePage, gxPageInfoRecord *, void *imageData);
  1319.  
  1320. enum {
  1321.     uppGXRenderPageProcInfo = kCStackBased
  1322.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1323.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
  1324.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxShape)))
  1325.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxPageInfoRecord*)))
  1326.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
  1327. };
  1328.  
  1329. #if USESROUTINEDESCRIPTORS
  1330. typedef UniversalProcPtr GXRenderPageUPP;
  1331.  
  1332. #define CallGXRenderPageProc(userRoutine, theFormat, thePage, parameter2, imageData)        \
  1333.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXRenderPageProcInfo, (theFormat), (thePage), (parameter2), (imageData))
  1334. #define NewGXRenderPageProc(userRoutine)        \
  1335.         (GXRenderPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXRenderPageProcInfo, GetCurrentISA())
  1336. #else
  1337. typedef GXRenderPageProcPtr GXRenderPageUPP;
  1338.  
  1339. #define CallGXRenderPageProc(userRoutine, theFormat, thePage, parameter2, imageData)        \
  1340.         (*(userRoutine))((theFormat), (thePage), (parameter2), (imageData))
  1341. #define NewGXRenderPageProc(userRoutine)        \
  1342.         (GXRenderPageUPP)(userRoutine)
  1343. #endif
  1344.  
  1345. extern OSErr Send_GXRenderPage(gxFormat theFormat, gxShape thePage, gxPageInfoRecord *, void *imageData)
  1346.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 34, 0xABFB);
  1347. extern OSErr Forward_GXRenderPage(gxFormat theFormat, gxShape thePage, gxPageInfoRecord *, void *imageData)
  1348.  TWOWORDINLINE(0x7036, 0xABFB);
  1349. typedef OSErr (*GXCreateImageFileProcPtr)(FSSpecPtr pFileSpec, long imageFileOptions, long *theImageFile);
  1350.  
  1351. enum {
  1352.     uppGXCreateImageFileProcInfo = kCStackBased
  1353.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1354.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(FSSpecPtr)))
  1355.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  1356.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long*)))
  1357. };
  1358.  
  1359. #if USESROUTINEDESCRIPTORS
  1360. typedef UniversalProcPtr GXCreateImageFileUPP;
  1361.  
  1362. #define CallGXCreateImageFileProc(userRoutine, pFileSpec, imageFileOptions, theImageFile)        \
  1363.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCreateImageFileProcInfo, (pFileSpec), (imageFileOptions), (theImageFile))
  1364. #define NewGXCreateImageFileProc(userRoutine)        \
  1365.         (GXCreateImageFileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCreateImageFileProcInfo, GetCurrentISA())
  1366. #else
  1367. typedef GXCreateImageFileProcPtr GXCreateImageFileUPP;
  1368.  
  1369. #define CallGXCreateImageFileProc(userRoutine, pFileSpec, imageFileOptions, theImageFile)        \
  1370.         (*(userRoutine))((pFileSpec), (imageFileOptions), (theImageFile))
  1371. #define NewGXCreateImageFileProc(userRoutine)        \
  1372.         (GXCreateImageFileUPP)(userRoutine)
  1373. #endif
  1374.  
  1375. extern OSErr Send_GXCreateImageFile(FSSpecPtr pFileSpec, long imageFileOptions, long *theImageFile)
  1376.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 35, 0xABFB);
  1377. extern OSErr Forward_GXCreateImageFile(FSSpecPtr pFileSpec, long imageFileOptions, long *theImageFile)
  1378.  TWOWORDINLINE(0x7036, 0xABFB);
  1379. typedef OSErr (*GXOpenConnectionProcPtr)(void);
  1380.  
  1381. enum {
  1382.     uppGXOpenConnectionProcInfo = kCStackBased
  1383.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1384. };
  1385.  
  1386. #if USESROUTINEDESCRIPTORS
  1387. typedef UniversalProcPtr GXOpenConnectionUPP;
  1388.  
  1389. #define CallGXOpenConnectionProc(userRoutine)        \
  1390.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXOpenConnectionProcInfo)
  1391. #define NewGXOpenConnectionProc(userRoutine)        \
  1392.         (GXOpenConnectionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXOpenConnectionProcInfo, GetCurrentISA())
  1393. #else
  1394. typedef GXOpenConnectionProcPtr GXOpenConnectionUPP;
  1395.  
  1396. #define CallGXOpenConnectionProc(userRoutine)        \
  1397.         (*(userRoutine))()
  1398. #define NewGXOpenConnectionProc(userRoutine)        \
  1399.         (GXOpenConnectionUPP)(userRoutine)
  1400. #endif
  1401.  
  1402. extern OSErr Send_GXOpenConnection(void)
  1403.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 36, 0xABFB);
  1404. extern OSErr Forward_GXOpenConnection(void)
  1405.  TWOWORDINLINE(0x7036, 0xABFB);
  1406. typedef OSErr (*GXCloseConnectionProcPtr)(void);
  1407.  
  1408. enum {
  1409.     uppGXCloseConnectionProcInfo = kCStackBased
  1410.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1411. };
  1412.  
  1413. #if USESROUTINEDESCRIPTORS
  1414. typedef UniversalProcPtr GXCloseConnectionUPP;
  1415.  
  1416. #define CallGXCloseConnectionProc(userRoutine)        \
  1417.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCloseConnectionProcInfo)
  1418. #define NewGXCloseConnectionProc(userRoutine)        \
  1419.         (GXCloseConnectionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCloseConnectionProcInfo, GetCurrentISA())
  1420. #else
  1421. typedef GXCloseConnectionProcPtr GXCloseConnectionUPP;
  1422.  
  1423. #define CallGXCloseConnectionProc(userRoutine)        \
  1424.         (*(userRoutine))()
  1425. #define NewGXCloseConnectionProc(userRoutine)        \
  1426.         (GXCloseConnectionUPP)(userRoutine)
  1427. #endif
  1428.  
  1429. extern OSErr Send_GXCloseConnection(void)
  1430.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 37, 0xABFB);
  1431. extern OSErr Forward_GXCloseConnection(void)
  1432.  TWOWORDINLINE(0x7036, 0xABFB);
  1433. typedef OSErr (*GXStartSendPageProcPtr)(gxFormat theFormat);
  1434.  
  1435. enum {
  1436.     uppGXStartSendPageProcInfo = kCStackBased
  1437.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1438.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
  1439. };
  1440.  
  1441. #if USESROUTINEDESCRIPTORS
  1442. typedef UniversalProcPtr GXStartSendPageUPP;
  1443.  
  1444. #define CallGXStartSendPageProc(userRoutine, theFormat)        \
  1445.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXStartSendPageProcInfo, (theFormat))
  1446. #define NewGXStartSendPageProc(userRoutine)        \
  1447.         (GXStartSendPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXStartSendPageProcInfo, GetCurrentISA())
  1448. #else
  1449. typedef GXStartSendPageProcPtr GXStartSendPageUPP;
  1450.  
  1451. #define CallGXStartSendPageProc(userRoutine, theFormat)        \
  1452.         (*(userRoutine))((theFormat))
  1453. #define NewGXStartSendPageProc(userRoutine)        \
  1454.         (GXStartSendPageUPP)(userRoutine)
  1455. #endif
  1456.  
  1457. extern OSErr Send_GXStartSendPage(gxFormat theFormat)
  1458.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 38, 0xABFB);
  1459. extern OSErr Forward_GXStartSendPage(gxFormat theFormat)
  1460.  TWOWORDINLINE(0x7036, 0xABFB);
  1461. typedef OSErr (*GXFinishSendPageProcPtr)(void);
  1462.  
  1463. enum {
  1464.     uppGXFinishSendPageProcInfo = kCStackBased
  1465.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1466. };
  1467.  
  1468. #if USESROUTINEDESCRIPTORS
  1469. typedef UniversalProcPtr GXFinishSendPageUPP;
  1470.  
  1471. #define CallGXFinishSendPageProc(userRoutine)        \
  1472.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFinishSendPageProcInfo)
  1473. #define NewGXFinishSendPageProc(userRoutine)        \
  1474.         (GXFinishSendPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFinishSendPageProcInfo, GetCurrentISA())
  1475. #else
  1476. typedef GXFinishSendPageProcPtr GXFinishSendPageUPP;
  1477.  
  1478. #define CallGXFinishSendPageProc(userRoutine)        \
  1479.         (*(userRoutine))()
  1480. #define NewGXFinishSendPageProc(userRoutine)        \
  1481.         (GXFinishSendPageUPP)(userRoutine)
  1482. #endif
  1483.  
  1484. extern OSErr Send_GXFinishSendPage(void)
  1485.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 39, 0xABFB);
  1486. extern OSErr Forward_GXFinishSendPage(void)
  1487.  TWOWORDINLINE(0x7036, 0xABFB);
  1488. typedef OSErr (*GXWriteDataProcPtr)(Ptr data, long length);
  1489.  
  1490. enum {
  1491.     uppGXWriteDataProcInfo = kCStackBased
  1492.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1493.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Ptr)))
  1494.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  1495. };
  1496.  
  1497. #if USESROUTINEDESCRIPTORS
  1498. typedef UniversalProcPtr GXWriteDataUPP;
  1499.  
  1500. #define CallGXWriteDataProc(userRoutine, data, length)        \
  1501.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXWriteDataProcInfo, (data), (length))
  1502. #define NewGXWriteDataProc(userRoutine)        \
  1503.         (GXWriteDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXWriteDataProcInfo, GetCurrentISA())
  1504. #else
  1505. typedef GXWriteDataProcPtr GXWriteDataUPP;
  1506.  
  1507. #define CallGXWriteDataProc(userRoutine, data, length)        \
  1508.         (*(userRoutine))((data), (length))
  1509. #define NewGXWriteDataProc(userRoutine)        \
  1510.         (GXWriteDataUPP)(userRoutine)
  1511. #endif
  1512.  
  1513. extern OSErr Send_GXWriteData(Ptr data, long length)
  1514.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 40, 0xABFB);
  1515. extern OSErr Forward_GXWriteData(Ptr data, long length)
  1516.  TWOWORDINLINE(0x7036, 0xABFB);
  1517. typedef OSErr (*GXBufferDataProcPtr)(Ptr data, long length, long bufferOptions);
  1518.  
  1519. enum {
  1520.     uppGXBufferDataProcInfo = kCStackBased
  1521.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1522.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Ptr)))
  1523.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  1524.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
  1525. };
  1526.  
  1527. #if USESROUTINEDESCRIPTORS
  1528. typedef UniversalProcPtr GXBufferDataUPP;
  1529.  
  1530. #define CallGXBufferDataProc(userRoutine, data, length, bufferOptions)        \
  1531.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXBufferDataProcInfo, (data), (length), (bufferOptions))
  1532. #define NewGXBufferDataProc(userRoutine)        \
  1533.         (GXBufferDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXBufferDataProcInfo, GetCurrentISA())
  1534. #else
  1535. typedef GXBufferDataProcPtr GXBufferDataUPP;
  1536.  
  1537. #define CallGXBufferDataProc(userRoutine, data, length, bufferOptions)        \
  1538.         (*(userRoutine))((data), (length), (bufferOptions))
  1539. #define NewGXBufferDataProc(userRoutine)        \
  1540.         (GXBufferDataUPP)(userRoutine)
  1541. #endif
  1542.  
  1543. extern OSErr Send_GXBufferData(Ptr data, long length, long bufferOptions)
  1544.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 41, 0xABFB);
  1545. extern OSErr Forward_GXBufferData(Ptr data, long length, long bufferOptions)
  1546.  TWOWORDINLINE(0x7036, 0xABFB);
  1547. typedef OSErr (*GXDumpBufferProcPtr)(gxPrintingBuffer *theBuffer);
  1548.  
  1549. enum {
  1550.     uppGXDumpBufferProcInfo = kCStackBased
  1551.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1552.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPrintingBuffer*)))
  1553. };
  1554.  
  1555. #if USESROUTINEDESCRIPTORS
  1556. typedef UniversalProcPtr GXDumpBufferUPP;
  1557.  
  1558. #define CallGXDumpBufferProc(userRoutine, theBuffer)        \
  1559.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDumpBufferProcInfo, (theBuffer))
  1560. #define NewGXDumpBufferProc(userRoutine)        \
  1561.         (GXDumpBufferUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDumpBufferProcInfo, GetCurrentISA())
  1562. #else
  1563. typedef GXDumpBufferProcPtr GXDumpBufferUPP;
  1564.  
  1565. #define CallGXDumpBufferProc(userRoutine, theBuffer)        \
  1566.         (*(userRoutine))((theBuffer))
  1567. #define NewGXDumpBufferProc(userRoutine)        \
  1568.         (GXDumpBufferUPP)(userRoutine)
  1569. #endif
  1570.  
  1571. extern OSErr Send_GXDumpBuffer(gxPrintingBuffer *theBuffer)
  1572.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 42, 0xABFB);
  1573. extern OSErr Forward_GXDumpBuffer(gxPrintingBuffer *theBuffer)
  1574.  TWOWORDINLINE(0x7036, 0xABFB);
  1575. typedef OSErr (*GXFreeBufferProcPtr)(gxPrintingBuffer *theBuffer);
  1576.  
  1577. enum {
  1578.     uppGXFreeBufferProcInfo = kCStackBased
  1579.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1580.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPrintingBuffer*)))
  1581. };
  1582.  
  1583. #if USESROUTINEDESCRIPTORS
  1584. typedef UniversalProcPtr GXFreeBufferUPP;
  1585.  
  1586. #define CallGXFreeBufferProc(userRoutine, theBuffer)        \
  1587.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFreeBufferProcInfo, (theBuffer))
  1588. #define NewGXFreeBufferProc(userRoutine)        \
  1589.         (GXFreeBufferUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFreeBufferProcInfo, GetCurrentISA())
  1590. #else
  1591. typedef GXFreeBufferProcPtr GXFreeBufferUPP;
  1592.  
  1593. #define CallGXFreeBufferProc(userRoutine, theBuffer)        \
  1594.         (*(userRoutine))((theBuffer))
  1595. #define NewGXFreeBufferProc(userRoutine)        \
  1596.         (GXFreeBufferUPP)(userRoutine)
  1597. #endif
  1598.  
  1599. extern OSErr Send_GXFreeBuffer(gxPrintingBuffer *theBuffer)
  1600.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 43, 0xABFB);
  1601. extern OSErr Forward_GXFreeBuffer(gxPrintingBuffer *theBuffer)
  1602.  TWOWORDINLINE(0x7036, 0xABFB);
  1603. #if defined(applec) && !defined(powerc)
  1604. typedef OSErr (*GXCheckStatusProcPtr)(Ptr data, long length, short statusType, Signature owner);
  1605.  
  1606. enum {
  1607.     uppGXCheckStatusProcInfo = kCStackBased
  1608.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1609.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Ptr)))
  1610.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  1611.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(short)))
  1612.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(Signature)))
  1613. };
  1614.  
  1615. #if USESROUTINEDESCRIPTORS
  1616. typedef UniversalProcPtr GXCheckStatusUPP;
  1617.  
  1618. #define CallGXCheckStatusProc(userRoutine, data, length, statusType, owner)        \
  1619.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCheckStatusProcInfo, (data), (length), (statusType), (owner))
  1620. #define NewGXCheckStatusProc(userRoutine)        \
  1621.         (GXCheckStatusUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCheckStatusProcInfo, GetCurrentISA())
  1622. #else
  1623. typedef GXCheckStatusProcPtr GXCheckStatusUPP;
  1624.  
  1625. #define CallGXCheckStatusProc(userRoutine, data, length, statusType, owner)        \
  1626.         (*(userRoutine))((data), (length), (statusType), (owner))
  1627. #define NewGXCheckStatusProc(userRoutine)        \
  1628.         (GXCheckStatusUPP)(userRoutine)
  1629. #endif
  1630.  
  1631. extern OSErr Send_GXCheckStatus(Ptr data, long length, short statusType, Signature owner)
  1632.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 44, 0xABFB);
  1633. extern OSErr Forward_GXCheckStatus(Ptr data, long length, short statusType, Signature owner)
  1634.  TWOWORDINLINE(0x7036, 0xABFB);
  1635. #else
  1636. typedef OSErr (*GXCheckStatusProcPtr)(Ptr data, long length, long statusType, Signature owner);
  1637.  
  1638. enum {
  1639.     uppGXCheckStatusProcInfo = kCStackBased
  1640.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1641.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Ptr)))
  1642.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  1643.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
  1644.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(Signature)))
  1645. };
  1646.  
  1647. #if USESROUTINEDESCRIPTORS
  1648. typedef UniversalProcPtr GXCheckStatusUPP;
  1649.  
  1650. #define CallGXCheckStatusProc(userRoutine, data, length, statusType, owner)        \
  1651.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCheckStatusProcInfo, (data), (length), (statusType), (owner))
  1652. #define NewGXCheckStatusProc(userRoutine)        \
  1653.         (GXCheckStatusUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCheckStatusProcInfo, GetCurrentISA())
  1654. #else
  1655. typedef GXCheckStatusProcPtr GXCheckStatusUPP;
  1656.  
  1657. #define CallGXCheckStatusProc(userRoutine, data, length, statusType, owner)        \
  1658.         (*(userRoutine))((data), (length), (statusType), (owner))
  1659. #define NewGXCheckStatusProc(userRoutine)        \
  1660.         (GXCheckStatusUPP)(userRoutine)
  1661. #endif
  1662.  
  1663. extern OSErr Send_GXCheckStatus(Ptr data, long length, long statusType, Signature owner)
  1664.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 44, 0xABFB);
  1665. extern OSErr Forward_GXCheckStatus(Ptr data, long length, long statusType, Signature owner)
  1666.  TWOWORDINLINE(0x7036, 0xABFB);
  1667. #endif
  1668.  
  1669. typedef OSErr (*GXGetDeviceStatusProcPtr)(Ptr cmdData, long cmdSize, Ptr responseData, long *responseSize, Str255 termination);
  1670.  
  1671. enum {
  1672.     uppGXGetDeviceStatusProcInfo = kCStackBased
  1673.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1674.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Ptr)))
  1675.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  1676.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Ptr)))
  1677.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long*)))
  1678.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(void* /* is array */)))
  1679. };
  1680.  
  1681. #if USESROUTINEDESCRIPTORS
  1682. typedef UniversalProcPtr GXGetDeviceStatusUPP;
  1683.  
  1684. #define CallGXGetDeviceStatusProc(userRoutine, cmdData, cmdSize, responseData, responseSize, termination)        \
  1685.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXGetDeviceStatusProcInfo, (cmdData), (cmdSize), (responseData), (responseSize), (termination))
  1686. #define NewGXGetDeviceStatusProc(userRoutine)        \
  1687.         (GXGetDeviceStatusUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXGetDeviceStatusProcInfo, GetCurrentISA())
  1688. #else
  1689. typedef GXGetDeviceStatusProcPtr GXGetDeviceStatusUPP;
  1690.  
  1691. #define CallGXGetDeviceStatusProc(userRoutine, cmdData, cmdSize, responseData, responseSize, termination)        \
  1692.         (*(userRoutine))((cmdData), (cmdSize), (responseData), (responseSize), (termination))
  1693. #define NewGXGetDeviceStatusProc(userRoutine)        \
  1694.         (GXGetDeviceStatusUPP)(userRoutine)
  1695. #endif
  1696.  
  1697. extern OSErr Send_GXGetDeviceStatus(Ptr cmdData, long cmdSize, Ptr responseData, long *responseSize, Str255 termination)
  1698.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 45, 0xABFB);
  1699. extern OSErr Forward_GXGetDeviceStatus(Ptr cmdData, long cmdSize, Ptr responseData, long *responseSize, Str255 termination)
  1700.  TWOWORDINLINE(0x7036, 0xABFB);
  1701. #if defined(applec) && !defined(powerc)
  1702. typedef OSErr (*GXFetchTaggedDataProcPtr)(ResType theType, short id, Handle *, Signature owner);
  1703.  
  1704. enum {
  1705.     uppGXFetchTaggedDataProcInfo = kCStackBased
  1706.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1707.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(ResType)))
  1708.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(short)))
  1709.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Handle*)))
  1710.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(Signature)))
  1711. };
  1712.  
  1713. #if USESROUTINEDESCRIPTORS
  1714. typedef UniversalProcPtr GXFetchTaggedDataUPP;
  1715.  
  1716. #define CallGXFetchTaggedDataProc(userRoutine, theType, id, parameter2, owner)        \
  1717.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFetchTaggedDataProcInfo, (theType), (id), (parameter2), (owner))
  1718. #define NewGXFetchTaggedDataProc(userRoutine)        \
  1719.         (GXFetchTaggedDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFetchTaggedDataProcInfo, GetCurrentISA())
  1720. #else
  1721. typedef GXFetchTaggedDataProcPtr GXFetchTaggedDataUPP;
  1722.  
  1723. #define CallGXFetchTaggedDataProc(userRoutine, theType, id, parameter2, owner)        \
  1724.         (*(userRoutine))((theType), (id), (parameter2), (owner))
  1725. #define NewGXFetchTaggedDataProc(userRoutine)        \
  1726.         (GXFetchTaggedDataUPP)(userRoutine)
  1727. #endif
  1728.  
  1729. extern OSErr Send_GXFetchTaggedData(ResType theType, short id, Handle *, Signature owner)
  1730.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 46, 0xABFB);
  1731. extern OSErr Forward_GXFetchTaggedData(ResType theType, short id, Handle *, Signature owner)
  1732.  TWOWORDINLINE(0x7036, 0xABFB);
  1733. #else
  1734. typedef OSErr (*GXFetchTaggedDataProcPtr)(ResType theType, long id, Handle *, Signature owner);
  1735.  
  1736. enum {
  1737.     uppGXFetchTaggedDataProcInfo = kCStackBased
  1738.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1739.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(ResType)))
  1740.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  1741.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Handle*)))
  1742.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(Signature)))
  1743. };
  1744.  
  1745. #if USESROUTINEDESCRIPTORS
  1746. typedef UniversalProcPtr GXFetchTaggedDataUPP;
  1747.  
  1748. #define CallGXFetchTaggedDataProc(userRoutine, theType, id, parameter2, owner)        \
  1749.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFetchTaggedDataProcInfo, (theType), (id), (parameter2), (owner))
  1750. #define NewGXFetchTaggedDataProc(userRoutine)        \
  1751.         (GXFetchTaggedDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFetchTaggedDataProcInfo, GetCurrentISA())
  1752. #else
  1753. typedef GXFetchTaggedDataProcPtr GXFetchTaggedDataUPP;
  1754.  
  1755. #define CallGXFetchTaggedDataProc(userRoutine, theType, id, parameter2, owner)        \
  1756.         (*(userRoutine))((theType), (id), (parameter2), (owner))
  1757. #define NewGXFetchTaggedDataProc(userRoutine)        \
  1758.         (GXFetchTaggedDataUPP)(userRoutine)
  1759. #endif
  1760.  
  1761. extern OSErr Send_GXFetchTaggedData(ResType theType, long id, Handle *, Signature owner)
  1762.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 46, 0xABFB);
  1763. extern OSErr Forward_GXFetchTaggedData(ResType theType, long id, Handle *, Signature owner)
  1764.  TWOWORDINLINE(0x7036, 0xABFB);
  1765. #endif
  1766.  
  1767. typedef OSErr (*GXGetDTPMenuListProcPtr)(MenuHandle menuHdl);
  1768.  
  1769. enum {
  1770.     uppGXGetDTPMenuListProcInfo = kCStackBased
  1771.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1772.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(MenuHandle)))
  1773. };
  1774.  
  1775. #if USESROUTINEDESCRIPTORS
  1776. typedef UniversalProcPtr GXGetDTPMenuListUPP;
  1777.  
  1778. #define CallGXGetDTPMenuListProc(userRoutine, menuHdl)        \
  1779.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXGetDTPMenuListProcInfo, (menuHdl))
  1780. #define NewGXGetDTPMenuListProc(userRoutine)        \
  1781.         (GXGetDTPMenuListUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXGetDTPMenuListProcInfo, GetCurrentISA())
  1782. #else
  1783. typedef GXGetDTPMenuListProcPtr GXGetDTPMenuListUPP;
  1784.  
  1785. #define CallGXGetDTPMenuListProc(userRoutine, menuHdl)        \
  1786.         (*(userRoutine))((menuHdl))
  1787. #define NewGXGetDTPMenuListProc(userRoutine)        \
  1788.         (GXGetDTPMenuListUPP)(userRoutine)
  1789. #endif
  1790.  
  1791. extern OSErr Send_GXGetDTPMenuList(MenuHandle menuHdl)
  1792.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 47, 0xABFB);
  1793. extern OSErr Forward_GXGetDTPMenuList(MenuHandle menuHdl)
  1794.  TWOWORDINLINE(0x7036, 0xABFB);
  1795. #if defined(applec) && !defined(powerc)
  1796. typedef OSErr (*GXDTPMenuSelectProcPtr)(short id);
  1797.  
  1798. enum {
  1799.     uppGXDTPMenuSelectProcInfo = kCStackBased
  1800.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1801.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
  1802. };
  1803.  
  1804. #if USESROUTINEDESCRIPTORS
  1805. typedef UniversalProcPtr GXDTPMenuSelectUPP;
  1806.  
  1807. #define CallGXDTPMenuSelectProc(userRoutine, id)        \
  1808.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDTPMenuSelectProcInfo, (id))
  1809. #define NewGXDTPMenuSelectProc(userRoutine)        \
  1810.         (GXDTPMenuSelectUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDTPMenuSelectProcInfo, GetCurrentISA())
  1811. #else
  1812. typedef GXDTPMenuSelectProcPtr GXDTPMenuSelectUPP;
  1813.  
  1814. #define CallGXDTPMenuSelectProc(userRoutine, id)        \
  1815.         (*(userRoutine))((id))
  1816. #define NewGXDTPMenuSelectProc(userRoutine)        \
  1817.         (GXDTPMenuSelectUPP)(userRoutine)
  1818. #endif
  1819.  
  1820. extern OSErr Send_GXDTPMenuSelect(short id)
  1821.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 48, 0xABFB);
  1822. extern OSErr Forward_GXDTPMenuSelect(short id)
  1823.  TWOWORDINLINE(0x7036, 0xABFB);
  1824. #else
  1825. typedef OSErr (*GXDTPMenuSelectProcPtr)(long id);
  1826.  
  1827. enum {
  1828.     uppGXDTPMenuSelectProcInfo = kCStackBased
  1829.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1830.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(long)))
  1831. };
  1832.  
  1833. #if USESROUTINEDESCRIPTORS
  1834. typedef UniversalProcPtr GXDTPMenuSelectUPP;
  1835.  
  1836. #define CallGXDTPMenuSelectProc(userRoutine, id)        \
  1837.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDTPMenuSelectProcInfo, (id))
  1838. #define NewGXDTPMenuSelectProc(userRoutine)        \
  1839.         (GXDTPMenuSelectUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDTPMenuSelectProcInfo, GetCurrentISA())
  1840. #else
  1841. typedef GXDTPMenuSelectProcPtr GXDTPMenuSelectUPP;
  1842.  
  1843. #define CallGXDTPMenuSelectProc(userRoutine, id)        \
  1844.         (*(userRoutine))((id))
  1845. #define NewGXDTPMenuSelectProc(userRoutine)        \
  1846.         (GXDTPMenuSelectUPP)(userRoutine)
  1847. #endif
  1848.  
  1849. extern OSErr Send_GXDTPMenuSelect(long id)
  1850.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 48, 0xABFB);
  1851. extern OSErr Forward_GXDTPMenuSelect(long id)
  1852.  TWOWORDINLINE(0x7036, 0xABFB);
  1853. #endif
  1854.  
  1855. typedef OSErr (*GXHandleAlertFilterProcPtr)(gxJob theJob, gxStatusRecord *pStatusRec, DialogPtr pDialog, EventRecord *theEvent, short *itemHit, Boolean *returnImmed);
  1856.  
  1857. enum {
  1858.     uppGXHandleAlertFilterProcInfo = kCStackBased
  1859.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1860.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxJob)))
  1861.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxStatusRecord*)))
  1862.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(DialogPtr)))
  1863.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(EventRecord*)))
  1864.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(short*)))
  1865.          | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(Boolean*)))
  1866. };
  1867.  
  1868. #if USESROUTINEDESCRIPTORS
  1869. typedef UniversalProcPtr GXHandleAlertFilterUPP;
  1870.  
  1871. #define CallGXHandleAlertFilterProc(userRoutine, theJob, pStatusRec, pDialog, theEvent, itemHit, returnImmed)        \
  1872.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXHandleAlertFilterProcInfo, (theJob), (pStatusRec), (pDialog), (theEvent), (itemHit), (returnImmed))
  1873. #define NewGXHandleAlertFilterProc(userRoutine)        \
  1874.         (GXHandleAlertFilterUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXHandleAlertFilterProcInfo, GetCurrentISA())
  1875. #else
  1876. typedef GXHandleAlertFilterProcPtr GXHandleAlertFilterUPP;
  1877.  
  1878. #define CallGXHandleAlertFilterProc(userRoutine, theJob, pStatusRec, pDialog, theEvent, itemHit, returnImmed)        \
  1879.         (*(userRoutine))((theJob), (pStatusRec), (pDialog), (theEvent), (itemHit), (returnImmed))
  1880. #define NewGXHandleAlertFilterProc(userRoutine)        \
  1881.         (GXHandleAlertFilterUPP)(userRoutine)
  1882. #endif
  1883.  
  1884. extern OSErr Send_GXHandleAlertFilter(gxJob theJob, gxStatusRecord *pStatusRec, DialogPtr pDialog, EventRecord *theEvent, short *itemHit, Boolean *returnImmed)
  1885.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 49, 0xABFB);
  1886. extern OSErr Forward_GXHandleAlertFilter(gxJob theJob, gxStatusRecord *pStatusRec, DialogPtr pDialog, EventRecord *theEvent, short *itemHit, Boolean *returnImmed)
  1887.  TWOWORDINLINE(0x7036, 0xABFB);
  1888. typedef OSErr (*GXJobFormatModeQueryProcPtr)(gxQueryType theQuery, void *srcData, void *dstData);
  1889.  
  1890. enum {
  1891.     uppGXJobFormatModeQueryProcInfo = kCStackBased
  1892.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1893.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxQueryType)))
  1894.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  1895.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void*)))
  1896. };
  1897.  
  1898. #if USESROUTINEDESCRIPTORS
  1899. typedef UniversalProcPtr GXJobFormatModeQueryUPP;
  1900.  
  1901. #define CallGXJobFormatModeQueryProc(userRoutine, theQuery, srcData, dstData)        \
  1902.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXJobFormatModeQueryProcInfo, (theQuery), (srcData), (dstData))
  1903. #define NewGXJobFormatModeQueryProc(userRoutine)        \
  1904.         (GXJobFormatModeQueryUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXJobFormatModeQueryProcInfo, GetCurrentISA())
  1905. #else
  1906. typedef GXJobFormatModeQueryProcPtr GXJobFormatModeQueryUPP;
  1907.  
  1908. #define CallGXJobFormatModeQueryProc(userRoutine, theQuery, srcData, dstData)        \
  1909.         (*(userRoutine))((theQuery), (srcData), (dstData))
  1910. #define NewGXJobFormatModeQueryProc(userRoutine)        \
  1911.         (GXJobFormatModeQueryUPP)(userRoutine)
  1912. #endif
  1913.  
  1914. extern OSErr Send_GXJobFormatModeQuery(gxQueryType theQuery, void *srcData, void *dstData)
  1915.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 50, 0xABFB);
  1916. extern OSErr Forward_GXJobFormatModeQuery(gxQueryType theQuery, void *srcData, void *dstData)
  1917.  TWOWORDINLINE(0x7036, 0xABFB);
  1918. typedef OSErr (*GXWriteStatusToDTPWindowProcPtr)(gxStatusRecord *pStatusRec, gxDisplayRecord *pDisplay);
  1919.  
  1920. enum {
  1921.     uppGXWriteStatusToDTPWindowProcInfo = kCStackBased
  1922.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1923.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxStatusRecord*)))
  1924.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxDisplayRecord*)))
  1925. };
  1926.  
  1927. #if USESROUTINEDESCRIPTORS
  1928. typedef UniversalProcPtr GXWriteStatusToDTPWindowUPP;
  1929.  
  1930. #define CallGXWriteStatusToDTPWindowProc(userRoutine, pStatusRec, pDisplay)        \
  1931.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXWriteStatusToDTPWindowProcInfo, (pStatusRec), (pDisplay))
  1932. #define NewGXWriteStatusToDTPWindowProc(userRoutine)        \
  1933.         (GXWriteStatusToDTPWindowUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXWriteStatusToDTPWindowProcInfo, GetCurrentISA())
  1934. #else
  1935. typedef GXWriteStatusToDTPWindowProcPtr GXWriteStatusToDTPWindowUPP;
  1936.  
  1937. #define CallGXWriteStatusToDTPWindowProc(userRoutine, pStatusRec, pDisplay)        \
  1938.         (*(userRoutine))((pStatusRec), (pDisplay))
  1939. #define NewGXWriteStatusToDTPWindowProc(userRoutine)        \
  1940.         (GXWriteStatusToDTPWindowUPP)(userRoutine)
  1941. #endif
  1942.  
  1943. extern OSErr Send_GXWriteStatusToDTPWindow(gxStatusRecord *pStatusRec, gxDisplayRecord *pDisplay)
  1944.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 51, 0xABFB);
  1945. extern OSErr Forward_GXWriteStatusToDTPWindow(gxStatusRecord *pStatusRec, gxDisplayRecord *pDisplay)
  1946.  TWOWORDINLINE(0x7036, 0xABFB);
  1947. typedef OSErr (*GXInitializeStatusAlertProcPtr)(gxStatusRecord *pStatusRec, DialogPtr *pDialog);
  1948.  
  1949. enum {
  1950.     uppGXInitializeStatusAlertProcInfo = kCStackBased
  1951.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1952.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxStatusRecord*)))
  1953.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(DialogPtr*)))
  1954. };
  1955.  
  1956. #if USESROUTINEDESCRIPTORS
  1957. typedef UniversalProcPtr GXInitializeStatusAlertUPP;
  1958.  
  1959. #define CallGXInitializeStatusAlertProc(userRoutine, pStatusRec, pDialog)        \
  1960.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXInitializeStatusAlertProcInfo, (pStatusRec), (pDialog))
  1961. #define NewGXInitializeStatusAlertProc(userRoutine)        \
  1962.         (GXInitializeStatusAlertUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXInitializeStatusAlertProcInfo, GetCurrentISA())
  1963. #else
  1964. typedef GXInitializeStatusAlertProcPtr GXInitializeStatusAlertUPP;
  1965.  
  1966. #define CallGXInitializeStatusAlertProc(userRoutine, pStatusRec, pDialog)        \
  1967.         (*(userRoutine))((pStatusRec), (pDialog))
  1968. #define NewGXInitializeStatusAlertProc(userRoutine)        \
  1969.         (GXInitializeStatusAlertUPP)(userRoutine)
  1970. #endif
  1971.  
  1972. extern OSErr Send_GXInitializeStatusAlert(gxStatusRecord *pStatusRec, DialogPtr *pDialog)
  1973.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 52, 0xABFB);
  1974. extern OSErr Forward_GXInitializeStatusAlert(gxStatusRecord *pStatusRec, DialogPtr *pDialog)
  1975.  TWOWORDINLINE(0x7036, 0xABFB);
  1976. typedef OSErr (*GXHandleAlertStatusProcPtr)(gxStatusRecord *pStatusRec);
  1977.  
  1978. enum {
  1979.     uppGXHandleAlertStatusProcInfo = kCStackBased
  1980.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  1981.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxStatusRecord*)))
  1982. };
  1983.  
  1984. #if USESROUTINEDESCRIPTORS
  1985. typedef UniversalProcPtr GXHandleAlertStatusUPP;
  1986.  
  1987. #define CallGXHandleAlertStatusProc(userRoutine, pStatusRec)        \
  1988.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXHandleAlertStatusProcInfo, (pStatusRec))
  1989. #define NewGXHandleAlertStatusProc(userRoutine)        \
  1990.         (GXHandleAlertStatusUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXHandleAlertStatusProcInfo, GetCurrentISA())
  1991. #else
  1992. typedef GXHandleAlertStatusProcPtr GXHandleAlertStatusUPP;
  1993.  
  1994. #define CallGXHandleAlertStatusProc(userRoutine, pStatusRec)        \
  1995.         (*(userRoutine))((pStatusRec))
  1996. #define NewGXHandleAlertStatusProc(userRoutine)        \
  1997.         (GXHandleAlertStatusUPP)(userRoutine)
  1998. #endif
  1999.  
  2000. extern OSErr Send_GXHandleAlertStatus(gxStatusRecord *pStatusRec)
  2001.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 53, 0xABFB);
  2002. extern OSErr Forward_GXHandleAlertStatus(gxStatusRecord *pStatusRec)
  2003.  TWOWORDINLINE(0x7036, 0xABFB);
  2004. typedef OSErr (*GXHandleAlertEventProcPtr)(gxStatusRecord *pStatusRec, DialogPtr pDialog, EventRecord *theEvent, short *response);
  2005.  
  2006. enum {
  2007.     uppGXHandleAlertEventProcInfo = kCStackBased
  2008.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2009.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxStatusRecord*)))
  2010.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(DialogPtr)))
  2011.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(EventRecord*)))
  2012.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(short*)))
  2013. };
  2014.  
  2015. #if USESROUTINEDESCRIPTORS
  2016. typedef UniversalProcPtr GXHandleAlertEventUPP;
  2017.  
  2018. #define CallGXHandleAlertEventProc(userRoutine, pStatusRec, pDialog, theEvent, response)        \
  2019.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXHandleAlertEventProcInfo, (pStatusRec), (pDialog), (theEvent), (response))
  2020. #define NewGXHandleAlertEventProc(userRoutine)        \
  2021.         (GXHandleAlertEventUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXHandleAlertEventProcInfo, GetCurrentISA())
  2022. #else
  2023. typedef GXHandleAlertEventProcPtr GXHandleAlertEventUPP;
  2024.  
  2025. #define CallGXHandleAlertEventProc(userRoutine, pStatusRec, pDialog, theEvent, response)        \
  2026.         (*(userRoutine))((pStatusRec), (pDialog), (theEvent), (response))
  2027. #define NewGXHandleAlertEventProc(userRoutine)        \
  2028.         (GXHandleAlertEventUPP)(userRoutine)
  2029. #endif
  2030.  
  2031. extern OSErr Send_GXHandleAlertEvent(gxStatusRecord *pStatusRec, DialogPtr pDialog, EventRecord *theEvent, short *response)
  2032.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 54, 0xABFB);
  2033. extern OSErr Forward_GXHandleAlertEvent(gxStatusRecord *pStatusRec, DialogPtr pDialog, EventRecord *theEvent, short *response)
  2034.  TWOWORDINLINE(0x7036, 0xABFB);
  2035. typedef void (*GXCleanupStartJobProcPtr)(void);
  2036.  
  2037. enum {
  2038.     uppGXCleanupStartJobProcInfo = kCStackBased
  2039. };
  2040.  
  2041. #if USESROUTINEDESCRIPTORS
  2042. typedef UniversalProcPtr GXCleanupStartJobUPP;
  2043.  
  2044. #define CallGXCleanupStartJobProc(userRoutine)        \
  2045.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCleanupStartJobProcInfo)
  2046. #define NewGXCleanupStartJobProc(userRoutine)        \
  2047.         (GXCleanupStartJobUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCleanupStartJobProcInfo, GetCurrentISA())
  2048. #else
  2049. typedef GXCleanupStartJobProcPtr GXCleanupStartJobUPP;
  2050.  
  2051. #define CallGXCleanupStartJobProc(userRoutine)        \
  2052.         (*(userRoutine))()
  2053. #define NewGXCleanupStartJobProc(userRoutine)        \
  2054.         (GXCleanupStartJobUPP)(userRoutine)
  2055. #endif
  2056.  
  2057. extern void Send_GXCleanupStartJob(void)
  2058.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 55, 0xABFB);
  2059. extern void Forward_GXCleanupStartJob(void)
  2060.  TWOWORDINLINE(0x7036, 0xABFB);
  2061. typedef void (*GXCleanupStartPageProcPtr)(void);
  2062.  
  2063. enum {
  2064.     uppGXCleanupStartPageProcInfo = kCStackBased
  2065. };
  2066.  
  2067. #if USESROUTINEDESCRIPTORS
  2068. typedef UniversalProcPtr GXCleanupStartPageUPP;
  2069.  
  2070. #define CallGXCleanupStartPageProc(userRoutine)        \
  2071.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCleanupStartPageProcInfo)
  2072. #define NewGXCleanupStartPageProc(userRoutine)        \
  2073.         (GXCleanupStartPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCleanupStartPageProcInfo, GetCurrentISA())
  2074. #else
  2075. typedef GXCleanupStartPageProcPtr GXCleanupStartPageUPP;
  2076.  
  2077. #define CallGXCleanupStartPageProc(userRoutine)        \
  2078.         (*(userRoutine))()
  2079. #define NewGXCleanupStartPageProc(userRoutine)        \
  2080.         (GXCleanupStartPageUPP)(userRoutine)
  2081. #endif
  2082.  
  2083. extern void Send_GXCleanupStartPage(void)
  2084.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 56, 0xABFB);
  2085. extern void Forward_GXCleanupStartPage(void)
  2086.  TWOWORDINLINE(0x7036, 0xABFB);
  2087. typedef void (*GXCleanupOpenConnectionProcPtr)(void);
  2088.  
  2089. enum {
  2090.     uppGXCleanupOpenConnectionProcInfo = kCStackBased
  2091. };
  2092.  
  2093. #if USESROUTINEDESCRIPTORS
  2094. typedef UniversalProcPtr GXCleanupOpenConnectionUPP;
  2095.  
  2096. #define CallGXCleanupOpenConnectionProc(userRoutine)        \
  2097.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCleanupOpenConnectionProcInfo)
  2098. #define NewGXCleanupOpenConnectionProc(userRoutine)        \
  2099.         (GXCleanupOpenConnectionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCleanupOpenConnectionProcInfo, GetCurrentISA())
  2100. #else
  2101. typedef GXCleanupOpenConnectionProcPtr GXCleanupOpenConnectionUPP;
  2102.  
  2103. #define CallGXCleanupOpenConnectionProc(userRoutine)        \
  2104.         (*(userRoutine))()
  2105. #define NewGXCleanupOpenConnectionProc(userRoutine)        \
  2106.         (GXCleanupOpenConnectionUPP)(userRoutine)
  2107. #endif
  2108.  
  2109. extern void Send_GXCleanupOpenConnection(void)
  2110.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 57, 0xABFB);
  2111. extern void Forward_GXCleanupOpenConnection(void)
  2112.  TWOWORDINLINE(0x7036, 0xABFB);
  2113. typedef void (*GXCleanupStartSendPageProcPtr)(void);
  2114.  
  2115. enum {
  2116.     uppGXCleanupStartSendPageProcInfo = kCStackBased
  2117. };
  2118.  
  2119. #if USESROUTINEDESCRIPTORS
  2120. typedef UniversalProcPtr GXCleanupStartSendPageUPP;
  2121.  
  2122. #define CallGXCleanupStartSendPageProc(userRoutine)        \
  2123.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCleanupStartSendPageProcInfo)
  2124. #define NewGXCleanupStartSendPageProc(userRoutine)        \
  2125.         (GXCleanupStartSendPageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCleanupStartSendPageProcInfo, GetCurrentISA())
  2126. #else
  2127. typedef GXCleanupStartSendPageProcPtr GXCleanupStartSendPageUPP;
  2128.  
  2129. #define CallGXCleanupStartSendPageProc(userRoutine)        \
  2130.         (*(userRoutine))()
  2131. #define NewGXCleanupStartSendPageProc(userRoutine)        \
  2132.         (GXCleanupStartSendPageUPP)(userRoutine)
  2133. #endif
  2134.  
  2135. extern void Send_GXCleanupStartSendPage(void)
  2136.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 58, 0xABFB);
  2137. extern void Forward_GXCleanupStartSendPage(void)
  2138.  TWOWORDINLINE(0x7036, 0xABFB);
  2139. typedef OSErr (*GXDefaultDesktopPrinterProcPtr)(Str31);
  2140.  
  2141. enum {
  2142.     uppGXDefaultDesktopPrinterProcInfo = kCStackBased
  2143.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2144.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(void* /* is array */)))
  2145. };
  2146.  
  2147. #if USESROUTINEDESCRIPTORS
  2148. typedef UniversalProcPtr GXDefaultDesktopPrinterUPP;
  2149.  
  2150. #define CallGXDefaultDesktopPrinterProc(userRoutine, parameter0)        \
  2151.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDefaultDesktopPrinterProcInfo, (parameter0))
  2152. #define NewGXDefaultDesktopPrinterProc(userRoutine)        \
  2153.         (GXDefaultDesktopPrinterUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDefaultDesktopPrinterProcInfo, GetCurrentISA())
  2154. #else
  2155. typedef GXDefaultDesktopPrinterProcPtr GXDefaultDesktopPrinterUPP;
  2156.  
  2157. #define CallGXDefaultDesktopPrinterProc(userRoutine, parameter0)        \
  2158.         (*(userRoutine))((parameter0))
  2159. #define NewGXDefaultDesktopPrinterProc(userRoutine)        \
  2160.         (GXDefaultDesktopPrinterUPP)(userRoutine)
  2161. #endif
  2162.  
  2163. extern OSErr Send_GXDefaultDesktopPrinter(Str31 dtpName)
  2164.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 59, 0xABFB);
  2165. extern OSErr Forward_GXDefaultDesktopPrinter(Str31 dtpName)
  2166.  TWOWORDINLINE(0x7036, 0xABFB);
  2167. typedef OSErr (*GXCaptureOutputDeviceProcPtr)(Boolean capture);
  2168.  
  2169. enum {
  2170.     uppGXCaptureOutputDeviceProcInfo = kCStackBased
  2171.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2172.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Boolean)))
  2173. };
  2174.  
  2175. #if USESROUTINEDESCRIPTORS
  2176. typedef UniversalProcPtr GXCaptureOutputDeviceUPP;
  2177.  
  2178. #define CallGXCaptureOutputDeviceProc(userRoutine, capture)        \
  2179.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXCaptureOutputDeviceProcInfo, (capture))
  2180. #define NewGXCaptureOutputDeviceProc(userRoutine)        \
  2181.         (GXCaptureOutputDeviceUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXCaptureOutputDeviceProcInfo, GetCurrentISA())
  2182. #else
  2183. typedef GXCaptureOutputDeviceProcPtr GXCaptureOutputDeviceUPP;
  2184.  
  2185. #define CallGXCaptureOutputDeviceProc(userRoutine, capture)        \
  2186.         (*(userRoutine))((capture))
  2187. #define NewGXCaptureOutputDeviceProc(userRoutine)        \
  2188.         (GXCaptureOutputDeviceUPP)(userRoutine)
  2189. #endif
  2190.  
  2191. extern OSErr Send_GXCaptureOutputDevice(Boolean capture)
  2192.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 60, 0xABFB);
  2193. extern OSErr Forward_GXCaptureOutputDevice(Boolean capture)
  2194.  TWOWORDINLINE(0x7036, 0xABFB);
  2195. typedef OSErr (*GXOpenConnectionRetryProcPtr)(ResType theType, void *, Boolean *retryopenPtr, OSErr anErr);
  2196.  
  2197. enum {
  2198.     uppGXOpenConnectionRetryProcInfo = kCStackBased
  2199.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2200.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(ResType)))
  2201.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  2202.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Boolean*)))
  2203.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(OSErr)))
  2204. };
  2205.  
  2206. #if USESROUTINEDESCRIPTORS
  2207. typedef UniversalProcPtr GXOpenConnectionRetryUPP;
  2208.  
  2209. #define CallGXOpenConnectionRetryProc(userRoutine, theType, parameter1, retryopenPtr, anErr)        \
  2210.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXOpenConnectionRetryProcInfo, (theType), (parameter1), (retryopenPtr), (anErr))
  2211. #define NewGXOpenConnectionRetryProc(userRoutine)        \
  2212.         (GXOpenConnectionRetryUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXOpenConnectionRetryProcInfo, GetCurrentISA())
  2213. #else
  2214. typedef GXOpenConnectionRetryProcPtr GXOpenConnectionRetryUPP;
  2215.  
  2216. #define CallGXOpenConnectionRetryProc(userRoutine, theType, parameter1, retryopenPtr, anErr)        \
  2217.         (*(userRoutine))((theType), (parameter1), (retryopenPtr), (anErr))
  2218. #define NewGXOpenConnectionRetryProc(userRoutine)        \
  2219.         (GXOpenConnectionRetryUPP)(userRoutine)
  2220. #endif
  2221.  
  2222. extern OSErr Send_GXOpenConnectionRetry(ResType theType, void *, Boolean *retryopenPtr, OSErr anErr)
  2223.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 61, 0xABFB);
  2224. extern OSErr Forward_GXOpenConnectionRetry(ResType theType, void *, Boolean *retryopenPtr, OSErr anErr)
  2225.  TWOWORDINLINE(0x7036, 0xABFB);
  2226. typedef OSErr (*GXExamineSpoolFileProcPtr)(gxSpoolFile theSpoolFile);
  2227.  
  2228. enum {
  2229.     uppGXExamineSpoolFileProcInfo = kCStackBased
  2230.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2231.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile)))
  2232. };
  2233.  
  2234. #if USESROUTINEDESCRIPTORS
  2235. typedef UniversalProcPtr GXExamineSpoolFileUPP;
  2236.  
  2237. #define CallGXExamineSpoolFileProc(userRoutine, theSpoolFile)        \
  2238.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXExamineSpoolFileProcInfo, (theSpoolFile))
  2239. #define NewGXExamineSpoolFileProc(userRoutine)        \
  2240.         (GXExamineSpoolFileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXExamineSpoolFileProcInfo, GetCurrentISA())
  2241. #else
  2242. typedef GXExamineSpoolFileProcPtr GXExamineSpoolFileUPP;
  2243.  
  2244. #define CallGXExamineSpoolFileProc(userRoutine, theSpoolFile)        \
  2245.         (*(userRoutine))((theSpoolFile))
  2246. #define NewGXExamineSpoolFileProc(userRoutine)        \
  2247.         (GXExamineSpoolFileUPP)(userRoutine)
  2248. #endif
  2249.  
  2250. extern OSErr Send_GXExamineSpoolFile(gxSpoolFile theSpoolFile)
  2251.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 62, 0xABFB);
  2252. extern OSErr Forward_GXExamineSpoolFile(gxSpoolFile theSpoolFile)
  2253.  TWOWORDINLINE(0x7036, 0xABFB);
  2254. typedef OSErr (*GXFinishSendPlaneProcPtr)(void);
  2255.  
  2256. enum {
  2257.     uppGXFinishSendPlaneProcInfo = kCStackBased
  2258.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2259. };
  2260.  
  2261. #if USESROUTINEDESCRIPTORS
  2262. typedef UniversalProcPtr GXFinishSendPlaneUPP;
  2263.  
  2264. #define CallGXFinishSendPlaneProc(userRoutine)        \
  2265.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFinishSendPlaneProcInfo)
  2266. #define NewGXFinishSendPlaneProc(userRoutine)        \
  2267.         (GXFinishSendPlaneUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFinishSendPlaneProcInfo, GetCurrentISA())
  2268. #else
  2269. typedef GXFinishSendPlaneProcPtr GXFinishSendPlaneUPP;
  2270.  
  2271. #define CallGXFinishSendPlaneProc(userRoutine)        \
  2272.         (*(userRoutine))()
  2273. #define NewGXFinishSendPlaneProc(userRoutine)        \
  2274.         (GXFinishSendPlaneUPP)(userRoutine)
  2275. #endif
  2276.  
  2277. extern OSErr Send_GXFinishSendPlane(void)
  2278.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 63, 0xABFB);
  2279. extern OSErr Forward_GXFinishSendPlane(void)
  2280.  TWOWORDINLINE(0x7036, 0xABFB);
  2281. typedef OSErr (*GXDoesPaperFitProcPtr)(gxTrayIndex whichTray, gxPaperType paper, Boolean *fits);
  2282.  
  2283. enum {
  2284.     uppGXDoesPaperFitProcInfo = kCStackBased
  2285.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2286.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxTrayIndex)))
  2287.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxPaperType)))
  2288.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Boolean*)))
  2289. };
  2290.  
  2291. #if USESROUTINEDESCRIPTORS
  2292. typedef UniversalProcPtr GXDoesPaperFitUPP;
  2293.  
  2294. #define CallGXDoesPaperFitProc(userRoutine, whichTray, paper, fits)        \
  2295.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXDoesPaperFitProcInfo, (whichTray), (paper), (fits))
  2296. #define NewGXDoesPaperFitProc(userRoutine)        \
  2297.         (GXDoesPaperFitUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXDoesPaperFitProcInfo, GetCurrentISA())
  2298. #else
  2299. typedef GXDoesPaperFitProcPtr GXDoesPaperFitUPP;
  2300.  
  2301. #define CallGXDoesPaperFitProc(userRoutine, whichTray, paper, fits)        \
  2302.         (*(userRoutine))((whichTray), (paper), (fits))
  2303. #define NewGXDoesPaperFitProc(userRoutine)        \
  2304.         (GXDoesPaperFitUPP)(userRoutine)
  2305. #endif
  2306.  
  2307. extern OSErr Send_GXDoesPaperFit(gxTrayIndex whichTray, gxPaperType paper, Boolean *fits)
  2308.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 64, 0xABFB);
  2309. extern OSErr Forward_GXDoesPaperFit(gxTrayIndex whichTray, gxPaperType paper, Boolean *fits)
  2310.  TWOWORDINLINE(0x7036, 0xABFB);
  2311. #if defined(applec) && !defined(powerc)
  2312. typedef OSErr (*GXChooserMessageProcPtr)(short message, short caller, StringPtr objName, StringPtr zoneName, ListHandle theList, long p2);
  2313.  
  2314. enum {
  2315.     uppGXChooserMessageProcInfo = kCStackBased
  2316.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2317.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
  2318.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(short)))
  2319.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(StringPtr)))
  2320.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(StringPtr)))
  2321.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(ListHandle)))
  2322.          | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(long)))
  2323. };
  2324.  
  2325. #if USESROUTINEDESCRIPTORS
  2326. typedef UniversalProcPtr GXChooserMessageUPP;
  2327.  
  2328. #define CallGXChooserMessageProc(userRoutine, message, caller, objName, zoneName, theList, p2)        \
  2329.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXChooserMessageProcInfo, (message), (caller), (objName), (zoneName), (theList), (p2))
  2330. #define NewGXChooserMessageProc(userRoutine)        \
  2331.         (GXChooserMessageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXChooserMessageProcInfo, GetCurrentISA())
  2332. #else
  2333. typedef GXChooserMessageProcPtr GXChooserMessageUPP;
  2334.  
  2335. #define CallGXChooserMessageProc(userRoutine, message, caller, objName, zoneName, theList, p2)        \
  2336.         (*(userRoutine))((message), (caller), (objName), (zoneName), (theList), (p2))
  2337. #define NewGXChooserMessageProc(userRoutine)        \
  2338.         (GXChooserMessageUPP)(userRoutine)
  2339. #endif
  2340.  
  2341. extern OSErr Send_GXChooserMessage(short message, short caller, StringPtr objName, StringPtr zoneName, ListHandle theList, long p2)
  2342.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 65, 0xABFB);
  2343. extern OSErr Forward_GXChooserMessage(short message, short caller, StringPtr objName, StringPtr zoneName, ListHandle theList, long p2)
  2344.  TWOWORDINLINE(0x7036, 0xABFB);
  2345. #else
  2346. typedef OSErr (*GXChooserMessageProcPtr)(long message, long caller, StringPtr objName, StringPtr zoneName, ListHandle theList, long p2);
  2347.  
  2348. enum {
  2349.     uppGXChooserMessageProcInfo = kCStackBased
  2350.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2351.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(long)))
  2352.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  2353.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(StringPtr)))
  2354.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(StringPtr)))
  2355.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(ListHandle)))
  2356.          | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(long)))
  2357. };
  2358.  
  2359. #if USESROUTINEDESCRIPTORS
  2360. typedef UniversalProcPtr GXChooserMessageUPP;
  2361.  
  2362. #define CallGXChooserMessageProc(userRoutine, message, caller, objName, zoneName, theList, p2)        \
  2363.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXChooserMessageProcInfo, (message), (caller), (objName), (zoneName), (theList), (p2))
  2364. #define NewGXChooserMessageProc(userRoutine)        \
  2365.         (GXChooserMessageUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXChooserMessageProcInfo, GetCurrentISA())
  2366. #else
  2367. typedef GXChooserMessageProcPtr GXChooserMessageUPP;
  2368.  
  2369. #define CallGXChooserMessageProc(userRoutine, message, caller, objName, zoneName, theList, p2)        \
  2370.         (*(userRoutine))((message), (caller), (objName), (zoneName), (theList), (p2))
  2371. #define NewGXChooserMessageProc(userRoutine)        \
  2372.         (GXChooserMessageUPP)(userRoutine)
  2373. #endif
  2374.  
  2375. extern OSErr Send_GXChooserMessage(long message, long caller, StringPtr objName, StringPtr zoneName, ListHandle theList, long p2)
  2376.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 65, 0xABFB);
  2377. extern OSErr Forward_GXChooserMessage(long message, long caller, StringPtr objName, StringPtr zoneName, ListHandle theList, long p2)
  2378.  TWOWORDINLINE(0x7036, 0xABFB);
  2379. #endif
  2380.  
  2381. typedef OSErr (*GXFindPrinterProfileProcPtr)(gxPrinter thePrinter, void *searchData, long index, gxColorProfile *returnedProfile, long *numProfiles);
  2382.  
  2383. enum {
  2384.     uppGXFindPrinterProfileProcInfo = kCStackBased
  2385.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2386.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPrinter)))
  2387.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  2388.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
  2389.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(gxColorProfile*)))
  2390.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(long*)))
  2391. };
  2392.  
  2393. #if USESROUTINEDESCRIPTORS
  2394. typedef UniversalProcPtr GXFindPrinterProfileUPP;
  2395.  
  2396. #define CallGXFindPrinterProfileProc(userRoutine, thePrinter, searchData, index, returnedProfile, numProfiles)        \
  2397.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFindPrinterProfileProcInfo, (thePrinter), (searchData), (index), (returnedProfile), (numProfiles))
  2398. #define NewGXFindPrinterProfileProc(userRoutine)        \
  2399.         (GXFindPrinterProfileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFindPrinterProfileProcInfo, GetCurrentISA())
  2400. #else
  2401. typedef GXFindPrinterProfileProcPtr GXFindPrinterProfileUPP;
  2402.  
  2403. #define CallGXFindPrinterProfileProc(userRoutine, thePrinter, searchData, index, returnedProfile, numProfiles)        \
  2404.         (*(userRoutine))((thePrinter), (searchData), (index), (returnedProfile), (numProfiles))
  2405. #define NewGXFindPrinterProfileProc(userRoutine)        \
  2406.         (GXFindPrinterProfileUPP)(userRoutine)
  2407. #endif
  2408.  
  2409. extern OSErr Send_GXFindPrinterProfile(gxPrinter thePrinter, void *searchData, long index, gxColorProfile *returnedProfile, long *numProfiles)
  2410.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 66, 0xABFB);
  2411. extern OSErr Forward_GXFindPrinterProfile(gxPrinter thePrinter, void *searchData, long index, gxColorProfile *returnedProfile, long *numProfiles)
  2412.  TWOWORDINLINE(0x7036, 0xABFB);
  2413. typedef OSErr (*GXFindFormatProfileProcPtr)(gxFormat theFormat, void *searchData, long index, gxColorProfile *returnedProfile, long *numProfiles);
  2414.  
  2415. enum {
  2416.     uppGXFindFormatProfileProcInfo = kCStackBased
  2417.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2418.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
  2419.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  2420.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
  2421.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(gxColorProfile*)))
  2422.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(long*)))
  2423. };
  2424.  
  2425. #if USESROUTINEDESCRIPTORS
  2426. typedef UniversalProcPtr GXFindFormatProfileUPP;
  2427.  
  2428. #define CallGXFindFormatProfileProc(userRoutine, theFormat, searchData, index, returnedProfile, numProfiles)        \
  2429.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXFindFormatProfileProcInfo, (theFormat), (searchData), (index), (returnedProfile), (numProfiles))
  2430. #define NewGXFindFormatProfileProc(userRoutine)        \
  2431.         (GXFindFormatProfileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXFindFormatProfileProcInfo, GetCurrentISA())
  2432. #else
  2433. typedef GXFindFormatProfileProcPtr GXFindFormatProfileUPP;
  2434.  
  2435. #define CallGXFindFormatProfileProc(userRoutine, theFormat, searchData, index, returnedProfile, numProfiles)        \
  2436.         (*(userRoutine))((theFormat), (searchData), (index), (returnedProfile), (numProfiles))
  2437. #define NewGXFindFormatProfileProc(userRoutine)        \
  2438.         (GXFindFormatProfileUPP)(userRoutine)
  2439. #endif
  2440.  
  2441. extern OSErr Send_GXFindFormatProfile(gxFormat theFormat, void *searchData, long index, gxColorProfile *returnedProfile, long *numProfiles)
  2442.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 67, 0xABFB);
  2443. extern OSErr Forward_GXFindFormatProfile(gxFormat theFormat, void *searchData, long index, gxColorProfile *returnedProfile, long *numProfiles)
  2444.  TWOWORDINLINE(0x7036, 0xABFB);
  2445. typedef OSErr (*GXSetPrinterProfileProcPtr)(gxPrinter thePrinter, gxColorProfile oldProfile, gxColorProfile newProfile);
  2446.  
  2447. enum {
  2448.     uppGXSetPrinterProfileProcInfo = kCStackBased
  2449.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2450.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxPrinter)))
  2451.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxColorProfile)))
  2452.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxColorProfile)))
  2453. };
  2454.  
  2455. #if USESROUTINEDESCRIPTORS
  2456. typedef UniversalProcPtr GXSetPrinterProfileUPP;
  2457.  
  2458. #define CallGXSetPrinterProfileProc(userRoutine, thePrinter, oldProfile, newProfile)        \
  2459.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSetPrinterProfileProcInfo, (thePrinter), (oldProfile), (newProfile))
  2460. #define NewGXSetPrinterProfileProc(userRoutine)        \
  2461.         (GXSetPrinterProfileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSetPrinterProfileProcInfo, GetCurrentISA())
  2462. #else
  2463. typedef GXSetPrinterProfileProcPtr GXSetPrinterProfileUPP;
  2464.  
  2465. #define CallGXSetPrinterProfileProc(userRoutine, thePrinter, oldProfile, newProfile)        \
  2466.         (*(userRoutine))((thePrinter), (oldProfile), (newProfile))
  2467. #define NewGXSetPrinterProfileProc(userRoutine)        \
  2468.         (GXSetPrinterProfileUPP)(userRoutine)
  2469. #endif
  2470.  
  2471. extern OSErr Send_GXSetPrinterProfile(gxPrinter thePrinter, gxColorProfile oldProfile, gxColorProfile newProfile)
  2472.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 68, 0xABFB);
  2473. extern OSErr Forward_GXSetPrinterProfile(gxPrinter thePrinter, gxColorProfile oldProfile, gxColorProfile newProfile)
  2474.  TWOWORDINLINE(0x7036, 0xABFB);
  2475. typedef OSErr (*GXSetFormatProfileProcPtr)(gxFormat theFormat, gxColorProfile oldProfile, gxColorProfile newProfile);
  2476.  
  2477. enum {
  2478.     uppGXSetFormatProfileProcInfo = kCStackBased
  2479.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  2480.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxFormat)))
  2481.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(gxColorProfile)))
  2482.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(gxColorProfile)))
  2483. };
  2484.  
  2485. #if USESROUTINEDESCRIPTORS
  2486. typedef UniversalProcPtr GXSetFormatProfileUPP;
  2487.  
  2488. #define CallGXSetFormatProfileProc(userRoutine, theFormat, oldProfile, newProfile)        \
  2489.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppGXSetFormatProfileProcInfo, (theFormat), (oldProfile), (newProfile))
  2490. #define NewGXSetFormatProfileProc(userRoutine)        \
  2491.         (GXSetFormatProfileUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppGXSetFormatProfileProcInfo, GetCurrentISA())
  2492. #else
  2493. typedef GXSetFormatProfileProcPtr GXSetFormatProfileUPP;
  2494.  
  2495. #define CallGXSetFormatProfileProc(userRoutine, theFormat, oldProfile, newProfile)        \
  2496.         (*(userRoutine))((theFormat), (oldProfile), (newProfile))
  2497. #define NewGXSetFormatProfileProc(userRoutine)        \
  2498.         (GXSetFormatProfileUPP)(userRoutine)
  2499. #endif
  2500.  
  2501. extern OSErr Send_GXSetFormatProfile(gxFormat theFormat, gxColorProfile oldProfile, gxColorProfile newProfile)
  2502.  FIVEWORDINLINE(0x7032, 0x223C, 0x0000, 69, 0xABFB);
  2503. extern OSErr Forward_GXSetFormatProfile(gxFormat theFormat, gxColorProfile oldProfile, gxColorProfile newProfile)
  2504.  TWOWORDINLINE(0x7036, 0xABFB);
  2505. #ifdef __cplusplus
  2506. }
  2507. #endif
  2508.  
  2509. #endif
  2510.  
  2511.